home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 November / CPNL0711.ISO / boekhoud / finan / BADGER finance v1.0 beta 2.exe / xampplite / phpMyAdmin / libraries / sqlparser.lib.php < prev    next >
PHP Script  |  2006-01-17  |  94KB  |  2,349 lines
  1. <?php
  2. /* $Id: sqlparser.lib.php,v 2.47 2006/01/17 17:02:30 cybot_tm Exp $ */
  3. // vim: expandtab sw=4 ts=4 sts=4:
  4.  
  5. /** SQL Parser Functions for phpMyAdmin
  6.  *
  7.  * Copyright 2002 Robin Johnson <robbat2@users.sourceforge.net>
  8.  * http://www.orbis-terrarum.net/?l=people.robbat2
  9.  *
  10.  * These functions define an SQL parser system, capable of understanding and
  11.  * extracting data from a MySQL type SQL query.
  12.  *
  13.  * The basic procedure for using the new SQL parser:
  14.  * On any page that needs to extract data from a query or to pretty-print a
  15.  * query, you need code like this up at the top:
  16.  *
  17.  * ($sql contains the query)
  18.  * $parsed_sql = PMA_SQP_parse($sql);
  19.  *
  20.  * If you want to extract data from it then, you just need to run
  21.  * $sql_info = PMA_SQP_analyze($parsed_sql);
  22.  *
  23.  * lem9: See comments in PMA_SQP_analyze for the returned info
  24.  *       from the analyzer.
  25.  *
  26.  * If you want a pretty-printed version of the query, do:
  27.  * $string = PMA_SQP_formatHtml($parsed_sql);
  28.  * (note that that you need to have syntax.css.php included somehow in your
  29.  * page for it to work, I recommend '<link rel="stylesheet" type="text/css"
  30.  * href="syntax.css.php" />' at the moment.)
  31.  */
  32.  
  33.  
  34. /**
  35.  * Minimum inclusion? (i.e. for the stylesheet builder)
  36.  */
  37. if ( ! defined( 'PMA_MINIMUM_COMMON' ) ) {
  38.     /**
  39.      * Include the string library as we use it heavily
  40.      */
  41.     require_once('./libraries/string.lib.php');
  42.  
  43.     /**
  44.      * Include data for the SQL Parser
  45.      */
  46.     require_once('./libraries/sqlparser.data.php');
  47.     require_once('./libraries/mysql_charsets.lib.php');
  48.     if (!isset($mysql_charsets)) {
  49.         $mysql_charsets = array();
  50.         $mysql_charsets_count = 0;
  51.         $mysql_collations_flat = array();
  52.         $mysql_collations_count = 0;
  53.     }
  54.  
  55.     if (!defined('DEBUG_TIMING')) {
  56.         function PMA_SQP_arrayAdd(&$arr, $type, $data, &$arrsize)
  57.         {
  58.             $arr[] = array('type' => $type, 'data' => $data);
  59.             $arrsize++;
  60.         } // end of the "PMA_SQP_arrayAdd()" function
  61.     } else {
  62.         function PMA_SQP_arrayAdd(&$arr, $type, $data, &$arrsize)
  63.         {
  64.             global $timer;
  65.  
  66.             $t     = $timer;
  67.             $arr[] = array('type' => $type, 'data' => $data, 'time' => $t);
  68.             $timer = microtime();
  69.             $arrsize++;
  70.         } // end of the "PMA_SQP_arrayAdd()" function
  71.     } // end if... else...
  72.  
  73.  
  74.     /**
  75.      * Reset the error variable for the SQL parser
  76.      *
  77.      * @access public
  78.      */
  79.     // Added, Robbat2 - 13 Janurary 2003, 2:59PM
  80.     function PMA_SQP_resetError()
  81.     {
  82.         global $SQP_errorString;
  83.         $SQP_errorString = '';
  84.         unset($SQP_errorString);
  85.     }
  86.  
  87.     /**
  88.      * Get the contents of the error variable for the SQL parser
  89.      *
  90.      * @return string Error string from SQL parser
  91.      *
  92.      * @access public
  93.      */
  94.     // Added, Robbat2 - 13 Janurary 2003, 2:59PM
  95.     function PMA_SQP_getErrorString()
  96.     {
  97.         global $SQP_errorString;
  98.         return isset($SQP_errorString) ? $SQP_errorString : '';
  99.     }
  100.  
  101.     /**
  102.      * Check if the SQL parser hit an error
  103.      *
  104.      * @return boolean error state
  105.      *
  106.      * @access public
  107.      */
  108.     // Added, Robbat2 - 13 Janurary 2003, 2:59PM
  109.     function PMA_SQP_isError()
  110.     {
  111.         global $SQP_errorString;
  112.         return isset($SQP_errorString) && !empty($SQP_errorString);
  113.     }
  114.  
  115.     /**
  116.      * Set an error message for the system
  117.      *
  118.      * @param  string  The error message
  119.      * @param  string  The failing SQL query
  120.      *
  121.      * @access private
  122.      * @scope SQL Parser internal
  123.      */
  124.     // Revised, Robbat2 - 13 Janurary 2003, 2:59PM
  125.     function PMA_SQP_throwError($message, $sql)
  126.     {
  127.  
  128.         global $SQP_errorString;
  129.         $SQP_errorString = '<p>'.$GLOBALS['strSQLParserUserError'] . '</p>' . "\n"
  130.             . '<pre>' . "\n"
  131.             . 'ERROR: ' . $message . "\n"
  132.             . 'SQL: ' . htmlspecialchars($sql) .  "\n"
  133.             . '</pre>' . "\n";
  134.  
  135.     } // end of the "PMA_SQP_throwError()" function
  136.  
  137.  
  138.     /**
  139.      * Do display the bug report
  140.      *
  141.      * @param  string  The error message
  142.      * @param  string  The failing SQL query
  143.      *
  144.      * @access public
  145.      */
  146.     function PMA_SQP_bug($message, $sql)
  147.     {
  148.         global $SQP_errorString;
  149.         $debugstr = 'ERROR: ' . $message . "\n";
  150.         $debugstr .= 'CVS: $Id: sqlparser.lib.php,v 2.47 2006/01/17 17:02:30 cybot_tm Exp $' . "\n";
  151.         $debugstr .= 'MySQL: '.PMA_MYSQL_STR_VERSION . "\n";
  152.         $debugstr .= 'USR OS, AGENT, VER: ' . PMA_USR_OS . ' ' . PMA_USR_BROWSER_AGENT . ' ' . PMA_USR_BROWSER_VER . "\n";
  153.         $debugstr .= 'PMA: ' . PMA_VERSION . "\n";
  154.         $debugstr .= 'PHP VER,OS: ' . PMA_PHP_STR_VERSION . ' ' . PHP_OS . "\n";
  155.         $debugstr .= 'LANG: ' . $GLOBALS['lang'] . "\n";
  156.         $debugstr .= 'SQL: ' . htmlspecialchars($sql);
  157.  
  158.         $encodedstr     = $debugstr;
  159.         if (@function_exists('gzcompress')) {
  160.             $encodedstr = gzcompress($debugstr, 9);
  161.         }
  162.         $encodedstr     = preg_replace("/(\015\012)|(\015)|(\012)/", '<br />' . "\n", chunk_split(base64_encode($encodedstr)));
  163.  
  164.         $SQP_errorString .= $GLOBALS['strSQLParserBugMessage'] . '<br />' . "\n"
  165.              . '----' . $GLOBALS['strBeginCut'] . '----' . '<br />' . "\n"
  166.              . $encodedstr . "\n"
  167.              . '----' . $GLOBALS['strEndCut'] . '----' . '<br />' . "\n";
  168.  
  169.         $SQP_errorString .= '----' . $GLOBALS['strBeginRaw'] . '----<br />' . "\n"
  170.              . '<pre>' . "\n"
  171.              . $debugstr
  172.              . '</pre>' . "\n"
  173.              . '----' . $GLOBALS['strEndRaw'] . '----<br />' . "\n";
  174.  
  175.     } // end of the "PMA_SQP_bug()" function
  176.  
  177.  
  178.     /**
  179.      * Parses the SQL queries
  180.      *
  181.      * @param  string   The SQL query list
  182.      *
  183.      * @return mixed    Most of times, nothing...
  184.      *
  185.      * @global array    The current PMA configuration
  186.      * @global array    MySQL column attributes
  187.      * @global array    MySQL reserved words
  188.      * @global array    MySQL column types
  189.      * @global array    MySQL function names
  190.      * @global integer  MySQL column attributes count
  191.      * @global integer  MySQL reserved words count
  192.      * @global integer  MySQL column types count
  193.      * @global integer  MySQL function names count
  194.      * @global array    List of available character sets
  195.      * @global array    List of available collations
  196.      * @global integer  Character sets count
  197.      * @global integer  Collations count
  198.      *
  199.      * @access public
  200.      */
  201.     function PMA_SQP_parse($sql)
  202.     {
  203.         global $cfg;
  204.         global $PMA_SQPdata_column_attrib, $PMA_SQPdata_reserved_word, $PMA_SQPdata_column_type, $PMA_SQPdata_function_name,
  205.                $PMA_SQPdata_column_attrib_cnt, $PMA_SQPdata_reserved_word_cnt, $PMA_SQPdata_column_type_cnt, $PMA_SQPdata_function_name_cnt;
  206.         global $mysql_charsets, $mysql_collations_flat, $mysql_charsets_count, $mysql_collations_count;
  207.         global $PMA_SQPdata_forbidden_word, $PMA_SQPdata_forbidden_word_cnt;
  208.  
  209.         // rabus: Convert all line feeds to Unix style
  210.         $sql = str_replace("\r\n", "\n", $sql);
  211.         $sql = str_replace("\r", "\n", $sql);
  212.  
  213.         $len = PMA_strlen($sql);
  214.         if ($len == 0) {
  215.             return array();
  216.         }
  217.  
  218.         $sql_array               = array();
  219.         $sql_array['raw']        = $sql;
  220.         $count1                  = 0;
  221.         $count2                  = 0;
  222.         $punct_queryend          = ';';
  223.         $punct_qualifier         = '.';
  224.         $punct_listsep           = ',';
  225.         $punct_level_plus        = '(';
  226.         $punct_level_minus       = ')';
  227.         $digit_floatdecimal      = '.';
  228.         $digit_hexset            = 'x';
  229.         $bracket_list            = '()[]{}';
  230.         $allpunct_list           =  '-,;:!?/.^~\*&%+<=>|';
  231.         $allpunct_list_pair      = array (
  232.             0 => '!=',
  233.             1 => '&&',
  234.             2 => ':=',
  235.             3 => '<<',
  236.             4 => '<=',
  237.             5 => '<=>',
  238.             6 => '<>',
  239.             7 => '>=',
  240.             8 => '>>',
  241.             9 => '||'
  242.         );
  243.         $allpunct_list_pair_size = 10; //count($allpunct_list_pair);
  244.         $quote_list              = '\'"`';
  245.         $arraysize               = 0;
  246.  
  247.         while ($count2 < $len) {
  248.             $c      = PMA_substr($sql, $count2, 1);
  249.             $count1 = $count2;
  250.  
  251.             if (($c == "\n")) {
  252.                 $count2++;
  253.                 PMA_SQP_arrayAdd($sql_array, 'white_newline', '', $arraysize);
  254.                 continue;
  255.             }
  256.  
  257.             // Checks for white space
  258.             if (PMA_STR_isSpace($c)) {
  259.                 $count2++;
  260.                 continue;
  261.             }
  262.  
  263.             // Checks for comment lines.
  264.             // MySQL style #
  265.             // C style /* */
  266.             // ANSI style --
  267.             if (($c == '#')
  268.                 || (($count2 + 1 < $len) && ($c == '/') && (PMA_substr($sql, $count2 + 1, 1) == '*'))
  269.                 || (($count2 + 2 == $len) && ($c == '-') && (PMA_substr($sql, $count2 + 1, 1) == '-'))
  270.                 || (($count2 + 2 < $len) && ($c == '-') && (PMA_substr($sql, $count2 + 1, 1) == '-') && ((PMA_substr($sql, $count2 + 2, 1) <= ' ')))) {
  271.                 $count2++;
  272.                 $pos  = 0;
  273.                 $type = 'bad';
  274.                 switch ($c) {
  275.                     case '#':
  276.                         $type = 'mysql';
  277.                     case '-':
  278.                         $type = 'ansi';
  279.                         $pos  = $GLOBALS['PMA_strpos']($sql, "\n", $count2);
  280.                         break;
  281.                     case '/':
  282.                         $type = 'c';
  283.                         $pos  = $GLOBALS['PMA_strpos']($sql, '*/', $count2);
  284.                         $pos  += 2;
  285.                         break;
  286.                     default:
  287.                         break;
  288.                 } // end switch
  289.                 $count2 = ($pos < $count2) ? $len : $pos;
  290.                 $str    = PMA_substr($sql, $count1, $count2 - $count1);
  291.                 PMA_SQP_arrayAdd($sql_array, 'comment_' . $type, $str, $arraysize);
  292.                 continue;
  293.             } // end if
  294.  
  295.             // Checks for something inside quotation marks
  296.             if (PMA_STR_strInStr($c, $quote_list)) {
  297.                 $startquotepos   = $count2;
  298.                 $quotetype       = $c;
  299.                 $count2++;
  300.                 $escaped         = FALSE;
  301.                 $escaped_escaped = FALSE;
  302.                 $pos             = $count2;
  303.                 $oldpos          = 0;
  304.                 do {
  305.                     $oldpos = $pos;
  306.                     $pos    = $GLOBALS['PMA_strpos'](' ' . $sql, $quotetype, $oldpos + 1) - 1;
  307.                     // ($pos === FALSE)
  308.                     if ($pos < 0) {
  309.                         $debugstr = $GLOBALS['strSQPBugUnclosedQuote'] . ' @ ' . $startquotepos. "\n"
  310.                                   . 'STR: ' . htmlspecialchars($quotetype);
  311.                         PMA_SQP_throwError($debugstr, $sql);
  312.                         return $sql;
  313.                     }
  314.  
  315.                     // If the quote is the first character, it can't be
  316.                     // escaped, so don't do the rest of the code
  317.                     if ($pos == 0) {
  318.                         break;
  319.                     }
  320.  
  321.                     // Checks for MySQL escaping using a \
  322.                     // And checks for ANSI escaping using the $quotetype character
  323.                     if (($pos < $len) && PMA_STR_charIsEscaped($sql, $pos)) {
  324.                         $pos ++;
  325.                         continue;
  326.                     } elseif (($pos + 1 < $len) && (PMA_substr($sql, $pos, 1) == $quotetype) && (PMA_substr($sql, $pos + 1, 1) == $quotetype)) {
  327.                         $pos = $pos + 2;
  328.                         continue;
  329.                     } else {
  330.                         break;
  331.                     }
  332.                 } while ($len > $pos); // end do
  333.  
  334.                 $count2       = $pos;
  335.                 $count2++;
  336.                 $type         = 'quote_';
  337.                 switch ($quotetype) {
  338.                     case '\'':
  339.                         $type .= 'single';
  340.                         break;
  341.                     case '"':
  342.                         $type .= 'double';
  343.                         break;
  344.                     case '`':
  345.                         $type .= 'backtick';
  346.                         break;
  347.                     default:
  348.                         break;
  349.                 } // end switch
  350.                 $data = PMA_substr($sql, $count1, $count2 - $count1);
  351.                 PMA_SQP_arrayAdd($sql_array, $type, $data, $arraysize);
  352.                 continue;
  353.             }
  354.  
  355.             // Checks for brackets
  356.             if (PMA_STR_strInStr($c, $bracket_list)) {
  357.                 // All bracket tokens are only one item long
  358.                 $count2++;
  359.                 $type_type     = '';
  360.                 if (PMA_STR_strInStr($c, '([{')) {
  361.                     $type_type = 'open';
  362.                 } else {
  363.                     $type_type = 'close';
  364.                 }
  365.  
  366.                 $type_style     = '';
  367.                 if (PMA_STR_strInStr($c, '()')) {
  368.                     $type_style = 'round';
  369.                 } elseif (PMA_STR_strInStr($c, '[]')) {
  370.                     $type_style = 'square';
  371.                 } else {
  372.                     $type_style = 'curly';
  373.                 }
  374.  
  375.                 $type = 'punct_bracket_' . $type_type . '_' . $type_style;
  376.                 PMA_SQP_arrayAdd($sql_array, $type, $c, $arraysize);
  377.                 continue;
  378.             }
  379.  
  380.             // Checks for identifier (alpha or numeric)
  381.             if (PMA_STR_isSqlIdentifier($c, FALSE) || ($c == '@') || ($c == '.' && PMA_STR_isDigit(PMA_substr($sql, $count2 + 1, 1)))) {
  382.                 $count2 ++;
  383.  
  384.                 //TODO: a @ can also be present in expressions like
  385.                 // FROM 'user'@'%'
  386.                 // or  TO 'user'@'%'
  387.                 // in this case, the @ is wrongly marked as alpha_variable
  388.  
  389.                 $is_sql_variable         = ($c == '@');
  390.                 $is_digit                = (!$is_sql_variable) && PMA_STR_isDigit($c);
  391.                 $is_hex_digit            = ($is_digit) && ($c == '.') && ($c == '0') && ($count2 < $len) && (PMA_substr($sql, $count2, 1) == 'x');
  392.                 $is_float_digit          = $c == '.';
  393.                 $is_float_digit_exponent = FALSE;
  394.  
  395.                 // Nijel: Fast skip is especially needed for huge BLOB data, requires PHP at least 4.3.0:
  396.                 if (PMA_PHP_INT_VERSION >= 40300) {
  397.                     if ($is_hex_digit) {
  398.                         $count2++;
  399.                         $pos = strspn($sql, '0123456789abcdefABCDEF', $count2);
  400.                         if ($pos > $count2) {
  401.                             $count2 = $pos;
  402.                         }
  403.                         unset($pos);
  404.                     } elseif ($is_digit) {
  405.                         $pos = strspn($sql, '0123456789', $count2);
  406.                         if ($pos > $count2) {
  407.                             $count2 = $pos;
  408.                         }
  409.                         unset($pos);
  410.                     }
  411.                 }
  412.  
  413.                 while (($count2 < $len) && PMA_STR_isSqlIdentifier(PMA_substr($sql, $count2, 1), ($is_sql_variable || $is_digit))) {
  414.                     $c2 = PMA_substr($sql, $count2, 1);
  415.                     if ($is_sql_variable && ($c2 == '.')) {
  416.                         $count2++;
  417.                         continue;
  418.                     }
  419.                     if ($is_digit && (!$is_hex_digit) && ($c2 == '.')) {
  420.                         $count2++;
  421.                         if (!$is_float_digit) {
  422.                             $is_float_digit = TRUE;
  423.                             continue;
  424.                         } else {
  425.                             $debugstr = $GLOBALS['strSQPBugInvalidIdentifer'] . ' @ ' . ($count1+1) . "\n"
  426.                                       . 'STR: ' . htmlspecialchars(PMA_substr($sql, $count1, $count2 - $count1));
  427.                             PMA_SQP_throwError($debugstr, $sql);
  428.                             return $sql;
  429.                         }
  430.                     }
  431.                     if ($is_digit && (!$is_hex_digit) && (($c2 == 'e') || ($c2 == 'E'))) {
  432.                         if (!$is_float_digit_exponent) {
  433.                             $is_float_digit_exponent = TRUE;
  434.                             $is_float_digit          = TRUE;
  435.                             $count2++;
  436.                             continue;
  437.                         } else {
  438.                             $is_digit                = FALSE;
  439.                             $is_float_digit          = FALSE;
  440.                         }
  441.                     }
  442.                     if (($is_hex_digit && PMA_STR_isHexDigit($c2)) || ($is_digit && PMA_STR_isDigit($c2))) {
  443.                         $count2++;
  444.                         continue;
  445.                     } else {
  446.                         $is_digit     = FALSE;
  447.                         $is_hex_digit = FALSE;
  448.                     }
  449.  
  450.                     $count2++;
  451.                 } // end while
  452.  
  453.                 $l    = $count2 - $count1;
  454.                 $str  = PMA_substr($sql, $count1, $l);
  455.  
  456.                 $type = '';
  457.                 if ($is_digit) {
  458.                     $type     = 'digit';
  459.                     if ($is_float_digit) {
  460.                         $type .= '_float';
  461.                     } elseif ($is_hex_digit) {
  462.                         $type .= '_hex';
  463.                     } else {
  464.                         $type .= '_integer';
  465.                     }
  466.                 } else {
  467.                     if ($is_sql_variable != FALSE) {
  468.                         $type = 'alpha_variable';
  469.                     } else {
  470.                         $type = 'alpha';
  471.                     }
  472.                 } // end if... else....
  473.                 PMA_SQP_arrayAdd($sql_array, $type, $str, $arraysize);
  474.  
  475.                 continue;
  476.             }
  477.  
  478.             // Checks for punct
  479.             if (PMA_STR_strInStr($c, $allpunct_list)) {
  480.                 while (($count2 < $len) && PMA_STR_strInStr(PMA_substr($sql, $count2, 1), $allpunct_list)) {
  481.                     $count2++;
  482.                 }
  483.                 $l = $count2 - $count1;
  484.                 if ($l == 1) {
  485.                     $punct_data = $c;
  486.                 } else {
  487.                     $punct_data = PMA_substr($sql, $count1, $l);
  488.                 }
  489.  
  490.                 // Special case, sometimes, althought two characters are
  491.                 // adjectent directly, they ACTUALLY need to be seperate
  492.                 if ($l == 1) {
  493.                     $t_suffix         = '';
  494.                     switch ($punct_data) {
  495.                         case $punct_queryend:
  496.                             $t_suffix = '_queryend';
  497.                             break;
  498.                         case $punct_qualifier:
  499.                             $t_suffix = '_qualifier';
  500.                             break;
  501.                         case $punct_listsep:
  502.                             $t_suffix = '_listsep';
  503.                             break;
  504.                         default:
  505.                             break;
  506.                     }
  507.                     PMA_SQP_arrayAdd($sql_array, 'punct' . $t_suffix, $punct_data, $arraysize);
  508.                 } elseif (PMA_STR_binarySearchInArr($punct_data, $allpunct_list_pair, $allpunct_list_pair_size)) {
  509.                     // Ok, we have one of the valid combined punct expressions
  510.                     PMA_SQP_arrayAdd($sql_array, 'punct', $punct_data, $arraysize);
  511.                 } else {
  512.                     // Bad luck, lets split it up more
  513.                     $first  = $punct_data[0];
  514.                     $first2 = $punct_data[0] . $punct_data[1];
  515.                     $last2  = $punct_data[$l - 2] . $punct_data[$l - 1];
  516.                     $last   = $punct_data[$l - 1];
  517.                     if (($first == ',') || ($first == ';') || ($first == '.') || ($first == '*')) {
  518.                         $count2     = $count1 + 1;
  519.                         $punct_data = $first;
  520.                     } elseif (($last2 == '/*') || (($last2 == '--') && ($count2 == $len || PMA_substr($sql, $count2, 1) <= ' ') )) {
  521.                         $count2     -= 2;
  522.                         $punct_data = PMA_substr($sql, $count1, $count2 - $count1);
  523.                     } elseif (($last == '-') || ($last == '+') || ($last == '!')) {
  524.                         $count2--;
  525.                         $punct_data = PMA_substr($sql, $count1, $count2 - $count1);
  526.                     // TODO: for negation operator, split in 2 tokens ?
  527.                     // "select x&~1 from t"
  528.                     // becomes "select x & ~ 1 from t" ?
  529.  
  530.                     } elseif ($last != '~') {
  531.                         $debugstr =  $GLOBALS['strSQPBugUnknownPunctuation'] . ' @ ' . ($count1+1) . "\n"
  532.                                   . 'STR: ' . htmlspecialchars($punct_data);
  533.                         PMA_SQP_throwError($debugstr, $sql);
  534.                         return $sql;
  535.                     }
  536.                     PMA_SQP_arrayAdd($sql_array, 'punct', $punct_data, $arraysize);
  537.                     continue;
  538.                 } // end if... elseif... else
  539.                 continue;
  540.             }
  541.  
  542.             // DEBUG
  543.             $count2++;
  544.  
  545.             $debugstr = 'C1 C2 LEN: ' . $count1 . ' ' . $count2 . ' ' . $len .  "\n"
  546.                       . 'STR: ' . PMA_substr($sql, $count1, $count2 - $count1) . "\n";
  547.             PMA_SQP_bug($debugstr, $sql);
  548.             return $sql;
  549.  
  550.         } // end while ($count2 < $len)
  551.  
  552.  
  553.         if ($arraysize > 0) {
  554.             $t_next           = $sql_array[0]['type'];
  555.             $t_prev           = '';
  556.             $t_bef_prev       = '';
  557.             $t_cur            = '';
  558.             $d_next           = $sql_array[0]['data'];
  559.             $d_prev           = '';
  560.             $d_bef_prev       = '';
  561.             $d_cur            = '';
  562.             $d_next_upper     = $t_next == 'alpha' ? strtoupper($d_next) : $d_next;
  563.             $d_prev_upper     = '';
  564.             $d_bef_prev_upper = '';
  565.             $d_cur_upper      = '';
  566.         }
  567.  
  568.         for ($i = 0; $i < $arraysize; $i++) {
  569.             $t_bef_prev       = $t_prev;
  570.             $t_prev           = $t_cur;
  571.             $t_cur            = $t_next;
  572.             $d_bef_prev       = $d_prev;
  573.             $d_prev           = $d_cur;
  574.             $d_cur            = $d_next;
  575.             $d_bef_prev_upper = $d_prev_upper;
  576.             $d_prev_upper     = $d_cur_upper;
  577.             $d_cur_upper      = $d_next_upper;
  578.             if (($i + 1) < $arraysize) {
  579.                 $t_next = $sql_array[$i + 1]['type'];
  580.                 $d_next = $sql_array[$i + 1]['data'];
  581.                 $d_next_upper = $t_next == 'alpha' ? strtoupper($d_next) : $d_next;
  582.             } else {
  583.                 $t_next       = '';
  584.                 $d_next       = '';
  585.                 $d_next_upper = '';
  586.             }
  587.  
  588.             //DEBUG echo "[prev: <b>".$d_prev."</b> ".$t_prev."][cur: <b>".$d_cur."</b> ".$t_cur."][next: <b>".$d_next."</b> ".$t_next."]<br />";
  589.  
  590.             if ($t_cur == 'alpha') {
  591.                 $t_suffix     = '_identifier';
  592.                 if (($t_next == 'punct_qualifier') || ($t_prev == 'punct_qualifier')) {
  593.                     $t_suffix = '_identifier';
  594.                 } elseif (($t_next == 'punct_bracket_open_round')
  595.                   && PMA_STR_binarySearchInArr($d_cur_upper, $PMA_SQPdata_function_name, $PMA_SQPdata_function_name_cnt)) {
  596.                     // FIXME-2005-10-16: in the case of a CREATE TABLE containing a TIMESTAMP,
  597.                     // since TIMESTAMP() is also a function, it's found here and
  598.                     // the token is wrongly marked as alpha_functionName. But we
  599.                     // compensate for this when analysing for timestamp_not_null
  600.                     // later in this script.
  601.                     $t_suffix = '_functionName';
  602.                 } elseif (PMA_STR_binarySearchInArr($d_cur_upper, $PMA_SQPdata_column_type, $PMA_SQPdata_column_type_cnt)) {
  603.                     $t_suffix = '_columnType';
  604.     
  605.                     // Temporary fix for BUG #621357
  606.                     //TODO FIX PROPERLY NEEDS OVERHAUL OF SQL TOKENIZER
  607.                     if ($d_cur_upper == 'SET' && $t_next != 'punct_bracket_open_round') {
  608.                         $t_suffix = '_reservedWord';
  609.                     }
  610.                     //END OF TEMPORARY FIX
  611.     
  612.                     // CHARACTER is a synonym for CHAR, but can also be meant as
  613.                     // CHARACTER SET. In this case, we have a reserved word.
  614.                     if ($d_cur_upper == 'CHARACTER' && $d_next_upper == 'SET') {
  615.                         $t_suffix = '_reservedWord';
  616.                     }
  617.     
  618.                     // experimental
  619.                     // current is a column type, so previous must not be
  620.                     // a reserved word but an identifier
  621.                     // CREATE TABLE SG_Persons (first varchar(64))
  622.     
  623.                     //if ($sql_array[$i-1]['type'] =='alpha_reservedWord') {
  624.                     //    $sql_array[$i-1]['type'] = 'alpha_identifier';
  625.                     //}
  626.     
  627.                 } elseif (PMA_STR_binarySearchInArr($d_cur_upper, $PMA_SQPdata_reserved_word, $PMA_SQPdata_reserved_word_cnt)) {
  628.                     $t_suffix = '_reservedWord';
  629.                 } elseif (PMA_STR_binarySearchInArr($d_cur_upper, $PMA_SQPdata_column_attrib, $PMA_SQPdata_column_attrib_cnt)) {
  630.                     $t_suffix = '_columnAttrib';
  631.                     // INNODB is a MySQL table type, but in "SHOW INNODB STATUS",
  632.                     // it should be regarded as a reserved word.
  633.                     if ($d_cur_upper == 'INNODB' && $d_prev_upper == 'SHOW' && $d_next_upper == 'STATUS') {
  634.                         $t_suffix = '_reservedWord';
  635.                     }
  636.     
  637.                     if ($d_cur_upper == 'DEFAULT' && $d_next_upper == 'CHARACTER') {
  638.                         $t_suffix = '_reservedWord';
  639.                     }
  640.                     // Binary as character set
  641.                     if ($d_cur_upper == 'BINARY' && (
  642.                       ($d_bef_prev_upper == 'CHARACTER' && $d_prev_upper == 'SET')
  643.                       || ($d_bef_prev_upper == 'SET' && $d_prev_upper == '=')
  644.                       || ($d_bef_prev_upper == 'CHARSET' && $d_prev_upper == '=')
  645.                       || $d_prev_upper == 'CHARSET'
  646.                       ) && PMA_STR_binarySearchInArr($d_cur, $mysql_charsets, count($mysql_charsets))) {
  647.                         $t_suffix = '_charset';
  648.                     }
  649.                 } elseif (PMA_STR_binarySearchInArr($d_cur, $mysql_charsets, $mysql_charsets_count)
  650.                   || PMA_STR_binarySearchInArr($d_cur, $mysql_collations_flat, $mysql_collations_count)
  651.                   || ($d_cur{0} == '_' && PMA_STR_binarySearchInArr(substr($d_cur, 1), $mysql_charsets, $mysql_charsets_count))) {
  652.                     $t_suffix = '_charset';
  653.                 } else {
  654.                     // Do nothing
  655.                 }
  656.                 // check if present in the list of forbidden words
  657.                 if ($t_suffix == '_reservedWord' && PMA_STR_binarySearchInArr($d_cur_upper, $PMA_SQPdata_forbidden_word, $PMA_SQPdata_forbidden_word_cnt)) {
  658.                     $sql_array[$i]['forbidden'] = TRUE;
  659.                 } else {
  660.                     $sql_array[$i]['forbidden'] = FALSE;
  661.                 }
  662.                 $sql_array[$i]['type'] .= $t_suffix;
  663.             }
  664.         } // end for
  665.  
  666.         // Stores the size of the array inside the array, as count() is a slow
  667.         // operation.
  668.         $sql_array['len'] = $arraysize;
  669.  
  670.         // Sends the data back
  671.         return $sql_array;
  672.     } // end of the "PMA_SQP_parse()" function
  673.  
  674.    /**
  675.     * Checks for token types being what we want...
  676.     *
  677.     * @param  string String of type that we have
  678.     * @param  string String of type that we want
  679.     *
  680.     * @return boolean result of check
  681.     *
  682.     * @access private
  683.     */
  684.     function PMA_SQP_typeCheck($toCheck, $whatWeWant)
  685.     {
  686.         $typeSeperator = '_';
  687.         if (strcmp($whatWeWant, $toCheck) == 0) {
  688.             return TRUE;
  689.         } else {
  690.             if (strpos($whatWeWant, $typeSeperator) === FALSE) {
  691.                 return strncmp($whatWeWant, $toCheck, strpos($toCheck, $typeSeperator)) == 0;
  692.             } else {
  693.                 return FALSE;
  694.             }
  695.         }
  696.     }
  697.  
  698.  
  699.     /**
  700.      * Analyzes SQL queries
  701.      *
  702.      * @param  array   The SQL queries
  703.      *
  704.      * @return array   The analyzed SQL queries
  705.      *
  706.      * @access public
  707.      */
  708.     function PMA_SQP_analyze($arr)
  709.     {
  710.         if ($arr == array()) {
  711.             return array();
  712.         }
  713.         $result          = array();
  714.         $size            = $arr['len'];
  715.         $subresult       = array(
  716.             'querytype'      => '',
  717.             'select_expr_clause'=> '', // the whole stuff between SELECT and FROM , except DISTINCT
  718.             'position_of_first_select' => '', // the array index
  719.             'from_clause'=> '',
  720.             'group_by_clause'=> '',
  721.             'order_by_clause'=> '',
  722.             'having_clause'  => '',
  723.             'where_clause'   => '',
  724.             'where_clause_identifiers'   => array(),
  725.             'unsorted_query' => '',
  726.             'queryflags'     => array(),
  727.             'select_expr'    => array(),
  728.             'table_ref'      => array(),
  729.             'foreign_keys'   => array(),
  730.             'create_table_fields' => array()
  731.         );
  732.         $subresult_empty = $subresult;
  733.         $seek_queryend         = FALSE;
  734.         $seen_end_of_table_ref = FALSE;
  735.         $number_of_brackets_in_extract = 0;
  736.         $number_of_brackets_in_group_concat = 0;
  737.  
  738.         // for SELECT EXTRACT(YEAR_MONTH FROM CURDATE())
  739.         // we must not use CURDATE as a table_ref
  740.         // so we track wether we are in the EXTRACT()
  741.         $in_extract          = FALSE;
  742.  
  743.         // for GROUP_CONCAT( ... )
  744.         $in_group_concat     = FALSE;
  745.  
  746. /* Description of analyzer results by lem9
  747.  *
  748.  * db, table, column, alias
  749.  * ------------------------
  750.  *
  751.  * Inside the $subresult array, we create ['select_expr'] and ['table_ref'] arrays.
  752.  *
  753.  * The SELECT syntax (simplified) is
  754.  *
  755.  * SELECT
  756.  *    select_expression,...
  757.  *    [FROM [table_references]
  758.  *
  759.  *
  760.  * ['select_expr'] is filled with each expression, the key represents the
  761.  * expression position in the list (0-based) (so we don't lose track of
  762.  * multiple occurences of the same column).
  763.  *
  764.  * ['table_ref'] is filled with each table ref, same thing for the key.
  765.  *
  766.  * I create all sub-values empty, even if they are
  767.  * not present (for example no select_expression alias).
  768.  *
  769.  * There is a debug section at the end of loop #1, if you want to
  770.  * see the exact contents of select_expr and table_ref
  771.  *
  772.  * queryflags
  773.  * ----------
  774.  *
  775.  * In $subresult, array 'queryflags' is filled, according to what we
  776.  * find in the query.
  777.  *
  778.  * Currently, those are generated:
  779.  *
  780.  * ['queryflags']['need_confirm'] = 1; if the query needs confirmation
  781.  * ['queryflags']['select_from'] = 1;  if this is a real SELECT...FROM
  782.  * ['queryflags']['distinct'] = 1;     for a DISTINCT
  783.  * ['queryflags']['union'] = 1;        for a UNION
  784.  * ['queryflags']['join'] = 1;         for a JOIN
  785.  * ['queryflags']['offset'] = 1;       for the presence of OFFSET
  786.  *
  787.  * query clauses
  788.  * -------------
  789.  *
  790.  * The select is splitted in those clauses:
  791.  * ['select_expr_clause']
  792.  * ['from_clause']
  793.  * ['group_by_clause']
  794.  * ['order_by_clause']
  795.  * ['having_clause']
  796.  * ['where_clause']
  797.  *
  798.  * The identifiers of the WHERE clause are put into the array
  799.  * ['where_clause_identifier']
  800.  *
  801.  * For a SELECT, the whole query without the ORDER BY clause is put into
  802.  * ['unsorted_query']
  803.  *
  804.  * foreign keys
  805.  * ------------
  806.  * The CREATE TABLE may contain FOREIGN KEY clauses, so they get
  807.  * analyzed and ['foreign_keys'] is an array filled with
  808.  * the constraint name, the index list,
  809.  * the REFERENCES table name and REFERENCES index list,
  810.  * and ON UPDATE | ON DELETE clauses
  811.  *
  812.  * position_of_first_select
  813.  * ------------------------
  814.  *
  815.  * The array index of the first SELECT we find. Will be used to
  816.  * insert a SQL_CALC_FOUND_ROWS.
  817.  *
  818.  * create_table_fields
  819.  * -------------------
  820.  *
  821.  * For now, mostly used to detect the DEFAULT CURRENT_TIMESTAMP and
  822.  * ON UPDATE CURRENT_TIMESTAMP clauses of the CREATE TABLE query.
  823.  * An array, each element is the identifier name.
  824.  * Note that for now, the timestamp_not_null element is created
  825.  * even for non-TIMESTAMP fields.
  826.  *
  827.  * Sub-elements: ['type'] which contains the column type
  828.  *               optional (currently they are never false but can be absent):
  829.  *               ['default_current_timestamp'] boolean
  830.  *               ['on_update_current_timestamp'] boolean
  831.  *               ['timestamp_not_null'] boolean
  832.  *
  833.  * section_before_limit, section_after_limit
  834.  * -----------------------------------------
  835.  *
  836.  * Marks the point of the query where we can insert a LIMIT clause;
  837.  * so the section_before_limit will contain the left part before
  838.  * a possible LIMIT clause
  839.  *
  840.  *
  841.  * End of description of analyzer results
  842.  */
  843.  
  844.         // must be sorted
  845.         // TODO: current logic checks for only one word, so I put only the
  846.         // first word of the reserved expressions that end a table ref;
  847.         // maybe this is not ok (the first word might mean something else)
  848. //        $words_ending_table_ref = array(
  849. //            'FOR UPDATE',
  850. //            'GROUP BY',
  851. //            'HAVING',
  852. //            'LIMIT',
  853. //            'LOCK IN SHARE MODE',
  854. //            'ORDER BY',
  855. //            'PROCEDURE',
  856. //            'UNION',
  857. //            'WHERE'
  858. //        );
  859.         $words_ending_table_ref = array(
  860.             'FOR',
  861.             'GROUP',
  862.             'HAVING',
  863.             'LIMIT',
  864.             'LOCK',
  865.             'ORDER',
  866.             'PROCEDURE',
  867.             'UNION',
  868.             'WHERE'
  869.         );
  870.         $words_ending_table_ref_cnt = 9; //count($words_ending_table_ref);
  871.  
  872.         $words_ending_clauses = array(
  873.             'FOR',
  874.             'LIMIT',
  875.             'LOCK',
  876.             'PROCEDURE',
  877.             'UNION'
  878.         );
  879.         $words_ending_clauses_cnt = 5; //count($words_ending_clauses);
  880.  
  881.  
  882.  
  883.  
  884.         // must be sorted
  885.         $supported_query_types = array(
  886.             'SELECT'
  887.             /*
  888.             // Support for these additional query types will come later on.
  889.             'DELETE',
  890.             'INSERT',
  891.             'REPLACE',
  892.             'TRUNCATE',
  893.             'UPDATE'
  894.             'EXPLAIN',
  895.             'DESCRIBE',
  896.             'SHOW',
  897.             'CREATE',
  898.             'SET',
  899.             'ALTER'
  900.             */
  901.         );
  902.         $supported_query_types_cnt = count($supported_query_types);
  903.  
  904.         // loop #1 for each token: select_expr, table_ref for SELECT
  905.  
  906.         for ($i = 0; $i < $size; $i++) {
  907. //DEBUG echo "trace loop1 <b>"  . $arr[$i]['data'] . "</b> (" . $arr[$i]['type'] . ")<br />";
  908.  
  909.             // High speed seek for locating the end of the current query
  910.             if ($seek_queryend == TRUE) {
  911.                 if ($arr[$i]['type'] == 'punct_queryend') {
  912.                     $seek_queryend = FALSE;
  913.                 } else {
  914.                     continue;
  915.                 } // end if (type == punct_queryend)
  916.             } // end if ($seek_queryend)
  917.  
  918.             // TODO: when we find a UNION, should we split
  919.             // in another subresult?
  920.             // Note: do not split if this is a punct_queryend for the
  921.             // first and only query
  922.             if ($arr[$i]['type'] == 'punct_queryend' && ($i + 1 != $size)) {
  923.                 $result[]  = $subresult;
  924.                 $subresult = $subresult_empty;
  925.                 continue;
  926.             } // end if (type == punct_queryend)
  927.  
  928. // ==============================================================
  929.             if ($arr[$i]['type'] == 'punct_bracket_open_round') {
  930.                 if ($in_extract) {
  931.                     $number_of_brackets_in_extract++;
  932.                 }
  933.                 if ($in_group_concat) {
  934.                     $number_of_brackets_in_group_concat++;
  935.                 }
  936.             }
  937. // ==============================================================
  938.             if ($arr[$i]['type'] == 'punct_bracket_close_round') {
  939.                 if ($in_extract) {
  940.                     $number_of_brackets_in_extract--;
  941.                     if ($number_of_brackets_in_extract == 0) {
  942.                        $in_extract = FALSE;
  943.                     }
  944.                 }
  945.                 if ($in_group_concat) {
  946.                     $number_of_brackets_in_group_concat--;
  947.                     if ($number_of_brackets_in_group_concat == 0) {
  948.                        $in_group_concat = FALSE;
  949.                     }
  950.                 }
  951.             }
  952. // ==============================================================
  953.             if ($arr[$i]['type'] == 'alpha_functionName') {
  954.                 $upper_data = strtoupper($arr[$i]['data']);
  955.                 if ($upper_data =='EXTRACT') {
  956.                     $in_extract = TRUE;
  957.                     $number_of_brackets_in_extract = 0;
  958.                 }
  959.                 if ($upper_data =='GROUP_CONCAT') {
  960.                     $in_group_concat = TRUE;
  961.                     $number_of_brackets_in_group_concat = 0;
  962.                 }
  963.             }
  964.  
  965. // ==============================================================
  966.             if ($arr[$i]['type'] == 'alpha_reservedWord'
  967. //             && $arr[$i]['forbidden'] == FALSE) {
  968.             ) {
  969.                 // We don't know what type of query yet, so run this
  970.                 if ($subresult['querytype'] == '') {
  971.                     $subresult['querytype'] = strtoupper($arr[$i]['data']);
  972.                 } // end if (querytype was empty)
  973.  
  974.                 // Check if we support this type of query
  975.                 if (!PMA_STR_binarySearchInArr($subresult['querytype'], $supported_query_types, $supported_query_types_cnt)) {
  976.                     // Skip ahead to the next one if we don't
  977.                     $seek_queryend = TRUE;
  978.                     continue;
  979.                 } // end if (query not supported)
  980.  
  981.                 // upper once
  982.                 $upper_data = strtoupper($arr[$i]['data']);
  983.                 //TODO: reset for each query?
  984.  
  985.                 if ($upper_data == 'SELECT') {
  986.                     $seen_from = FALSE;
  987.                     $previous_was_identifier = FALSE;
  988.                     $current_select_expr = -1;
  989.                     $seen_end_of_table_ref = FALSE;
  990.                 } // end if ( data == SELECT)
  991.  
  992.                 if ($upper_data =='FROM' && !$in_extract) {
  993.                     $current_table_ref = -1;
  994.                     $seen_from = TRUE;
  995.                     $previous_was_identifier = FALSE;
  996.                     $save_table_ref = TRUE;
  997.                 } // end if (data == FROM)
  998.  
  999.                 // here, do not 'continue' the loop, as we have more work for
  1000.                 // reserved words below
  1001.             } // end if (type == alpha_reservedWord)
  1002.  
  1003. // ==============================
  1004.             if ($arr[$i]['type'] == 'quote_backtick'
  1005.              || $arr[$i]['type'] == 'quote_double'
  1006.              || $arr[$i]['type'] == 'quote_single'
  1007.              || $arr[$i]['type'] == 'alpha_identifier'
  1008.              || ($arr[$i]['type'] == 'alpha_reservedWord'
  1009.                 && $arr[$i]['forbidden'] == FALSE)) {
  1010.  
  1011.                 switch ($arr[$i]['type']) {
  1012.                     case 'alpha_identifier':
  1013.                     case 'alpha_reservedWord':
  1014.                         // this is not a real reservedWord, because
  1015.                         // it's not present in the list of forbidden words,
  1016.                         // for example "storage" which can be used as
  1017.                         // an identifier
  1018.                         //
  1019.                         // TODO: avoid the pretty printing in color
  1020.                         //       in this case
  1021.  
  1022.                         $identifier = $arr[$i]['data'];
  1023.                         break;
  1024.  
  1025.                 //TODO: check embedded double quotes or backticks?
  1026.                 // and/or remove just the first and last character?
  1027.                     case 'quote_backtick':
  1028.                         $identifier = str_replace('`', '', $arr[$i]['data']);
  1029.                         break;
  1030.                     case 'quote_double':
  1031.                         $identifier = str_replace('"', '', $arr[$i]['data']);
  1032.                         break;
  1033.                     case 'quote_single':
  1034.                         $identifier = str_replace("'", "", $arr[$i]['data']);
  1035.                         break;
  1036.                 } // end switch
  1037.  
  1038.                 if ($subresult['querytype'] == 'SELECT' && !$in_group_concat) {
  1039.                     if (!$seen_from) {
  1040.                         if ($previous_was_identifier && isset($chain)) {
  1041.                             // found alias for this select_expr, save it
  1042.                             // but only if we got something in $chain
  1043.                             // (for example, SELECT COUNT(*) AS cnt
  1044.                             // puts nothing in $chain, so we avoid
  1045.                             // setting the alias)
  1046.                             $alias_for_select_expr = $identifier;
  1047.                         } else {
  1048.                             $chain[] = $identifier;
  1049.                             $previous_was_identifier = TRUE;
  1050.  
  1051.                         } // end if !$previous_was_identifier
  1052.                     } else {
  1053.                         // ($seen_from)
  1054.                         if ($save_table_ref && !$seen_end_of_table_ref) {
  1055.                             if ($previous_was_identifier) {
  1056.                                 // found alias for table ref
  1057.                                 // save it for later
  1058.                                 $alias_for_table_ref = $identifier;
  1059.                             } else {
  1060.                                 $chain[] = $identifier;
  1061.                                 $previous_was_identifier = TRUE;
  1062.  
  1063.                             } // end if ($previous_was_identifier)
  1064.                         } // end if ($save_table_ref &&!$seen_end_of_table_ref)
  1065.                     } // end if (!$seen_from)
  1066.                 } // end if (querytype SELECT)
  1067.             } // end if ( quote_backtick or double quote or alpha_identifier)
  1068.  
  1069. // ===================================
  1070.             if ($arr[$i]['type'] == 'punct_qualifier') {
  1071.                 // to be able to detect an identifier following another
  1072.                 $previous_was_identifier = FALSE;
  1073.                 continue;
  1074.             } // end if (punct_qualifier)
  1075.  
  1076.             // TODO: check if 3 identifiers following one another -> error
  1077.  
  1078.             //    s a v e    a    s e l e c t    e x p r
  1079.             // finding a list separator or FROM
  1080.             // means that we must save the current chain of identifiers
  1081.             // into a select expression
  1082.  
  1083.             // for now, we only save a select expression if it contains
  1084.             // at least one identifier, as we are interested in checking
  1085.             // the columns and table names, so in "select * from persons",
  1086.             // the "*" is not saved
  1087.  
  1088.             if (isset($chain) && !$seen_end_of_table_ref
  1089.                && (   (!$seen_from
  1090.                    && $arr[$i]['type'] == 'punct_listsep')
  1091.                   || ($arr[$i]['type'] == 'alpha_reservedWord' && $upper_data == 'FROM')) ) {
  1092.                 $size_chain = count($chain);
  1093.                 $current_select_expr++;
  1094.                 $subresult['select_expr'][$current_select_expr] = array(
  1095.                   'expr' => '',
  1096.                   'alias' => '',
  1097.                   'db'   => '',
  1098.                   'table_name' => '',
  1099.                   'table_true_name' => '',
  1100.                   'column' => ''
  1101.                  );
  1102.  
  1103.                 if (isset($alias_for_select_expr) && strlen($alias_for_select_expr)) {
  1104.                     // we had found an alias for this select expression
  1105.                     $subresult['select_expr'][$current_select_expr]['alias'] = $alias_for_select_expr;
  1106.                     unset($alias_for_select_expr);
  1107.                 }
  1108.                 // there is at least a column
  1109.                 $subresult['select_expr'][$current_select_expr]['column'] = $chain[$size_chain - 1];
  1110.                 $subresult['select_expr'][$current_select_expr]['expr'] = $chain[$size_chain - 1];
  1111.  
  1112.                 // maybe a table
  1113.                 if ($size_chain > 1) {
  1114.                     $subresult['select_expr'][$current_select_expr]['table_name'] = $chain[$size_chain - 2];
  1115.                     // we assume for now that this is also the true name
  1116.                     $subresult['select_expr'][$current_select_expr]['table_true_name'] = $chain[$size_chain - 2];
  1117.                     $subresult['select_expr'][$current_select_expr]['expr']
  1118.                      = $subresult['select_expr'][$current_select_expr]['table_name']
  1119.                       . '.' . $subresult['select_expr'][$current_select_expr]['expr'];
  1120.                 } // end if ($size_chain > 1)
  1121.  
  1122.                 // maybe a db
  1123.                 if ($size_chain > 2) {
  1124.                     $subresult['select_expr'][$current_select_expr]['db'] = $chain[$size_chain - 3];
  1125.                     $subresult['select_expr'][$current_select_expr]['expr']
  1126.                      = $subresult['select_expr'][$current_select_expr]['db']
  1127.                       . '.' . $subresult['select_expr'][$current_select_expr]['expr'];
  1128.                 } // end if ($size_chain > 2)
  1129.                 unset($chain);
  1130.  
  1131.                 // TODO: explain this:
  1132.                 if (($arr[$i]['type'] == 'alpha_reservedWord')
  1133.                  && ($upper_data != 'FROM')) {
  1134.                     $previous_was_identifier = TRUE;
  1135.                 }
  1136.  
  1137.             } // end if (save a select expr)
  1138.  
  1139.  
  1140.             //======================================
  1141.             //    s a v e    a    t a b l e    r e f
  1142.             //======================================
  1143.  
  1144.             // maybe we just saw the end of table refs
  1145.             // but the last table ref has to be saved
  1146.             // or we are at the last token (TODO: there could be another
  1147.             // query after this one)
  1148.             // or we just got a reserved word
  1149.  
  1150.             if (isset($chain) && $seen_from && $save_table_ref
  1151.              && ($arr[$i]['type'] == 'punct_listsep'
  1152.                || ($arr[$i]['type'] == 'alpha_reservedWord' && $upper_data!="AS")
  1153.                || $seen_end_of_table_ref
  1154.                || $i==$size-1 )) {
  1155.  
  1156.                 $size_chain = count($chain);
  1157.                 $current_table_ref++;
  1158.                 $subresult['table_ref'][$current_table_ref] = array(
  1159.                   'expr'            => '',
  1160.                   'db'              => '',
  1161.                   'table_name'      => '',
  1162.                   'table_alias'     => '',
  1163.                   'table_true_name' => ''
  1164.                  );
  1165.                 if (isset($alias_for_table_ref) && strlen($alias_for_table_ref)) {
  1166.                     $subresult['table_ref'][$current_table_ref]['table_alias'] = $alias_for_table_ref;
  1167.                     unset($alias_for_table_ref);
  1168.                 }
  1169.                 $subresult['table_ref'][$current_table_ref]['table_name'] = $chain[$size_chain - 1];
  1170.                 // we assume for now that this is also the true name
  1171.                 $subresult['table_ref'][$current_table_ref]['table_true_name'] = $chain[$size_chain - 1];
  1172.                 $subresult['table_ref'][$current_table_ref]['expr']
  1173.                      = $subresult['table_ref'][$current_table_ref]['table_name'];
  1174.                 // maybe a db
  1175.                 if ($size_chain > 1) {
  1176.                     $subresult['table_ref'][$current_table_ref]['db'] = $chain[$size_chain - 2];
  1177.                     $subresult['table_ref'][$current_table_ref]['expr']
  1178.                      = $subresult['table_ref'][$current_table_ref]['db']
  1179.                       . '.' . $subresult['table_ref'][$current_table_ref]['expr'];
  1180.                 } // end if ($size_chain > 1)
  1181.  
  1182.                 // add the table alias into the whole expression
  1183.                 $subresult['table_ref'][$current_table_ref]['expr']
  1184.                  .= ' ' . $subresult['table_ref'][$current_table_ref]['table_alias'];
  1185.  
  1186.                 unset($chain);
  1187.                 $previous_was_identifier = TRUE;
  1188.                 //continue;
  1189.  
  1190.             } // end if (save a table ref)
  1191.  
  1192.  
  1193.             // when we have found all table refs,
  1194.             // for each table_ref alias, put the true name of the table
  1195.             // in the corresponding select expressions
  1196.  
  1197.             if (isset($current_table_ref) && ($seen_end_of_table_ref || $i == $size-1) && $subresult != $subresult_empty) {
  1198.                 for ($tr=0; $tr <= $current_table_ref; $tr++) {
  1199.                     $alias = $subresult['table_ref'][$tr]['table_alias'];
  1200.                     $truename = $subresult['table_ref'][$tr]['table_true_name'];
  1201.                     for ($se=0; $se <= $current_select_expr; $se++) {
  1202.                         if (isset($alias) && strlen($alias) && $subresult['select_expr'][$se]['table_true_name']
  1203.                            == $alias) {
  1204.                             $subresult['select_expr'][$se]['table_true_name']
  1205.                              = $truename;
  1206.                         } // end if (found the alias)
  1207.                     } // end for (select expressions)
  1208.  
  1209.                 } // end for (table refs)
  1210.             } // end if (set the true names)
  1211.  
  1212.  
  1213.            // e n d i n g    l o o p  #1
  1214.            // set the $previous_was_identifier to FALSE if the current
  1215.            // token is not an identifier
  1216.            if (($arr[$i]['type'] != 'alpha_identifier')
  1217.             && ($arr[$i]['type'] != 'quote_double')
  1218.             && ($arr[$i]['type'] != 'quote_single')
  1219.             && ($arr[$i]['type'] != 'quote_backtick')) {
  1220.                $previous_was_identifier = FALSE;
  1221.            } // end if
  1222.  
  1223.            // however, if we are on AS, we must keep the $previous_was_identifier
  1224.            if (($arr[$i]['type'] == 'alpha_reservedWord')
  1225.             && ($upper_data == 'AS'))  {
  1226.                $previous_was_identifier = TRUE;
  1227.            }
  1228.  
  1229.            if (($arr[$i]['type'] == 'alpha_reservedWord')
  1230.             && ($upper_data =='ON' || $upper_data =='USING')) {
  1231.                $save_table_ref = FALSE;
  1232.            } // end if (data == ON)
  1233.  
  1234.            if (($arr[$i]['type'] == 'alpha_reservedWord')
  1235.             && ($upper_data =='JOIN' || $upper_data =='FROM')) {
  1236.                $save_table_ref = TRUE;
  1237.            } // end if (data == JOIN)
  1238.  
  1239.            // no need to check the end of table ref if we already did
  1240.            // TODO: maybe add "&& $seen_from"
  1241.            if (!$seen_end_of_table_ref) {
  1242.                // if this is the last token, it implies that we have
  1243.                // seen the end of table references
  1244.                // Check for the end of table references
  1245.                //
  1246.                // Note: if we are analyzing a GROUP_CONCAT clause,
  1247.                // we might find a word that seems to indicate that
  1248.                // we have found the end of table refs (like ORDER)
  1249.                // but it's a modifier of the GROUP_CONCAT so
  1250.                // it's not the real end of table refs
  1251.                if (($i == $size-1)
  1252.                  || ($arr[$i]['type'] == 'alpha_reservedWord'
  1253.                  && !$in_group_concat
  1254.                  && PMA_STR_binarySearchInArr($upper_data, $words_ending_table_ref, $words_ending_table_ref_cnt))) {
  1255.                    $seen_end_of_table_ref = TRUE;
  1256.                    // to be able to save the last table ref, but do not
  1257.                    // set it true if we found a word like "ON" that has
  1258.                    // already set it to false
  1259.                    if (isset($save_table_ref) && $save_table_ref != FALSE) {
  1260.                       $save_table_ref = TRUE;
  1261.                    } //end if
  1262.  
  1263.                } // end if (check for end of table ref)
  1264.            } //end if (!$seen_end_of_table_ref)
  1265.  
  1266.            if ($seen_end_of_table_ref) {
  1267.                $save_table_ref = FALSE;
  1268.            } // end if
  1269.  
  1270.         } // end for $i (loop #1)
  1271.  
  1272.         // -------------------------------------------------------
  1273.         // This is a big hunk of debugging code by Marc for this.
  1274.         // -------------------------------------------------------
  1275.         /*
  1276.           if (isset($current_select_expr)) {
  1277.            for ($trace=0; $trace<=$current_select_expr; $trace++) {
  1278.                echo "<br />";
  1279.                reset ($subresult['select_expr'][$trace]);
  1280.                while (list ($key, $val) = each ($subresult['select_expr'][$trace]))
  1281.                    echo "sel expr $trace $key => $val<br />\n";
  1282.                }
  1283.           }
  1284.  
  1285.           if (isset($current_table_ref)) {
  1286.            echo "current_table_ref = " . $current_table_ref . "<br>";
  1287.            for ($trace=0; $trace<=$current_table_ref; $trace++) {
  1288.  
  1289.                echo "<br />";
  1290.                reset ($subresult['table_ref'][$trace]);
  1291.                while (list ($key, $val) = each ($subresult['table_ref'][$trace]))
  1292.                echo "table ref $trace $key => $val<br />\n";
  1293.                }
  1294.           }
  1295.         */
  1296.         // -------------------------------------------------------
  1297.  
  1298.  
  1299.         // loop #2: - queryflags
  1300.         //          - querytype (for queries != 'SELECT')
  1301.         //          - section_before_limit, section_after_limit
  1302.         //
  1303.         // we will also need this queryflag in loop 2
  1304.         // so set it here
  1305.         if (isset($current_table_ref) && $current_table_ref > -1) {
  1306.             $subresult['queryflags']['select_from'] = 1;
  1307.         }
  1308.  
  1309.         $collect_section_before_limit = TRUE;
  1310.         $section_before_limit = '';
  1311.         $section_after_limit = '';
  1312.         $seen_reserved_word = FALSE;
  1313.         $seen_group = FALSE;
  1314.         $seen_order = FALSE;
  1315.         $in_group_by = FALSE; // true when we are inside the GROUP BY clause
  1316.         $in_order_by = FALSE; // true when we are inside the ORDER BY clause
  1317.         $in_having = FALSE; // true when we are inside the HAVING clause
  1318.         $in_select_expr = FALSE; // true when we are inside the select expr clause
  1319.         $in_where = FALSE; // true when we are inside the WHERE clause
  1320.         $in_from = FALSE;
  1321.         $in_group_concat = FALSE;
  1322.         $unsorted_query = '';
  1323.         $first_reserved_word = '';
  1324.         $current_identifier = '';
  1325.  
  1326.         for ($i = 0; $i < $size; $i++) {
  1327. //DEBUG echo "trace loop2 <b>"  . $arr[$i]['data'] . "</b> (" . $arr[$i]['type'] . ")<br />";
  1328.  
  1329.            // need_confirm
  1330.            //
  1331.            // check for reserved words that will have to generate
  1332.            // a confirmation request later in sql.php
  1333.            // the cases are:
  1334.            //   DROP TABLE
  1335.            //   DROP DATABASE
  1336.            //   ALTER TABLE... DROP
  1337.            //   DELETE FROM...
  1338.            //
  1339.            // this code is not used for confirmations coming from functions.js
  1340.  
  1341.            // TODO: check for punct_queryend
  1342.  
  1343.  
  1344.            // TODO: verify C-style comments?
  1345.            if ($arr[$i]['type'] == 'comment_ansi') {
  1346.                $collect_section_before_limit = FALSE;
  1347.            }
  1348.  
  1349.            if ($arr[$i]['type'] == 'alpha_reservedWord') {
  1350.                $upper_data = strtoupper($arr[$i]['data']);
  1351.                if (!$seen_reserved_word) {
  1352.                    $first_reserved_word = $upper_data;
  1353.                    $subresult['querytype'] = $upper_data;
  1354.                    $seen_reserved_word = TRUE;
  1355.  
  1356.                    // if the first reserved word is DROP or DELETE,
  1357.                    // we know this is a query that needs to be confirmed
  1358.                    if ($first_reserved_word=='DROP'
  1359.                        || $first_reserved_word == 'DELETE'
  1360.                        || $first_reserved_word == 'TRUNCATE') {
  1361.                       $subresult['queryflags']['need_confirm'] = 1;
  1362.                    }
  1363.  
  1364.                    if ($first_reserved_word=='SELECT'){
  1365.                        $position_of_first_select = $i;
  1366.                    }
  1367.  
  1368.                } else {
  1369.                    if ($upper_data=='DROP' && $first_reserved_word=='ALTER') {
  1370.                       $subresult['queryflags']['need_confirm'] = 1;
  1371.                    }
  1372.                }
  1373.  
  1374.                if ($upper_data == 'PROCEDURE') {
  1375.                    $collect_section_before_limit = FALSE;
  1376.                }
  1377.                // TODO: set also to FALSE if we find
  1378.                //      FOR UPDATE
  1379.                //      LOCK IN SHARE MODE
  1380.  
  1381.                if ($upper_data == 'SELECT') {
  1382.                    $in_select_expr = TRUE;
  1383.                    $select_expr_clause = '';
  1384.                }
  1385.                if ($upper_data == 'DISTINCT' && !$in_group_concat) {
  1386.                       $subresult['queryflags']['distinct'] = 1;
  1387.                }
  1388.  
  1389.                if ($upper_data == 'UNION') {
  1390.                       $subresult['queryflags']['union'] = 1;
  1391.                }
  1392.  
  1393.                if ($upper_data == 'JOIN') {
  1394.                       $subresult['queryflags']['join'] = 1;
  1395.                }
  1396.  
  1397.                if ($upper_data == 'OFFSET') {
  1398.                       $subresult['queryflags']['offset'] = 1;
  1399.                }
  1400.  
  1401.                // if this is a real SELECT...FROM
  1402.                if ($upper_data == 'FROM' && isset($subresult['queryflags']['select_from']) && $subresult['queryflags']['select_from'] == 1) {
  1403.                    $in_from = TRUE;
  1404.                    $from_clause = '';
  1405.                    $in_select_expr = FALSE;
  1406.                }
  1407.  
  1408.  
  1409.                // (we could have less resetting of variables to FALSE
  1410.                // if we trust that the query respects the standard
  1411.                // MySQL order for clauses)
  1412.  
  1413.                // we use $seen_group and $seen_order because we are looking
  1414.                // for the BY
  1415.                if ($upper_data == 'GROUP') {
  1416.                    $seen_group = TRUE;
  1417.                    $seen_order = FALSE;
  1418.                    $in_having = FALSE;
  1419.                    $in_order_by = FALSE;
  1420.                    $in_where = FALSE;
  1421.                    $in_select_expr = FALSE;
  1422.                    $in_from = FALSE;
  1423.                }
  1424.                if ($upper_data == 'ORDER' && !$in_group_concat) {
  1425.                    $seen_order = TRUE;
  1426.                    $seen_group = FALSE;
  1427.                    $in_having = FALSE;
  1428.                    $in_group_by = FALSE;
  1429.                    $in_where = FALSE;
  1430.                    $in_select_expr = FALSE;
  1431.                    $in_from = FALSE;
  1432.                }
  1433.                if ($upper_data == 'HAVING') {
  1434.                    $in_having = TRUE;
  1435.                    $having_clause = '';
  1436.                    $seen_group = FALSE;
  1437.                    $seen_order = FALSE;
  1438.                    $in_group_by = FALSE;
  1439.                    $in_order_by = FALSE;
  1440.                    $in_where = FALSE;
  1441.                    $in_select_expr = FALSE;
  1442.                    $in_from = FALSE;
  1443.                }
  1444.  
  1445.                if ($upper_data == 'WHERE') {
  1446.                    $in_where = TRUE;
  1447.                    $where_clause = '';
  1448.                    $where_clause_identifiers = array();
  1449.                    $seen_group = FALSE;
  1450.                    $seen_order = FALSE;
  1451.                    $in_group_by = FALSE;
  1452.                    $in_order_by = FALSE;
  1453.                    $in_having = FALSE;
  1454.                    $in_select_expr = FALSE;
  1455.                    $in_from = FALSE;
  1456.                }
  1457.  
  1458.                if ($upper_data == 'BY') {
  1459.                    if ($seen_group) {
  1460.                        $in_group_by = TRUE;
  1461.                        $group_by_clause = '';
  1462.                    }
  1463.                    if ($seen_order) {
  1464.                        $in_order_by = TRUE;
  1465.                        $order_by_clause = '';
  1466.                    }
  1467.                }
  1468.  
  1469.                // if we find one of the words that could end the clause
  1470.                if (PMA_STR_binarySearchInArr($upper_data, $words_ending_clauses, $words_ending_clauses_cnt)) {
  1471.  
  1472.                    $in_group_by = FALSE;
  1473.                    $in_order_by = FALSE;
  1474.                    $in_having   = FALSE;
  1475.                    $in_where    = FALSE;
  1476.                    $in_select_expr = FALSE;
  1477.                    $in_from = FALSE;
  1478.                }
  1479.  
  1480.            } // endif (reservedWord)
  1481.  
  1482.  
  1483.            // do not add a blank after a function name
  1484.            // TODO: can we combine loop 2 and loop 1?
  1485.            // some code is repeated here...
  1486.  
  1487.            $sep=' ';
  1488.            if ($arr[$i]['type'] == 'alpha_functionName') {
  1489.                $sep='';
  1490.                $upper_data = strtoupper($arr[$i]['data']);
  1491.                if ($upper_data =='GROUP_CONCAT') {
  1492.                    $in_group_concat = TRUE;
  1493.                    $number_of_brackets_in_group_concat = 0;
  1494.                }
  1495.            }
  1496.  
  1497.            if ($arr[$i]['type'] == 'punct_bracket_open_round') {
  1498.                if ($in_group_concat) {
  1499.                   $number_of_brackets_in_group_concat++;
  1500.                }
  1501.            }
  1502.            if ($arr[$i]['type'] == 'punct_bracket_close_round') {
  1503.                if ($in_group_concat) {
  1504.                   $number_of_brackets_in_group_concat--;
  1505.                   if ($number_of_brackets_in_group_concat == 0) {
  1506.                      $in_group_concat = FALSE;
  1507.                   }
  1508.                }
  1509.            }
  1510.  
  1511.            if ($in_select_expr && $upper_data != 'SELECT' && $upper_data != 'DISTINCT') {
  1512.                $select_expr_clause .= $arr[$i]['data'] . $sep;
  1513.            }
  1514.            if ($in_from && $upper_data != 'FROM') {
  1515.                $from_clause .= $arr[$i]['data'] . $sep;
  1516.            }
  1517.            if ($in_group_by && $upper_data != 'GROUP' && $upper_data != 'BY') {
  1518.                $group_by_clause .= $arr[$i]['data'] . $sep;
  1519.            }
  1520.            if ($in_order_by && $upper_data != 'ORDER' && $upper_data != 'BY') {
  1521.                $order_by_clause .= $arr[$i]['data'] . $sep;
  1522.            }
  1523.            if ($in_having && $upper_data != 'HAVING') {
  1524.                $having_clause .= $arr[$i]['data'] . $sep;
  1525.            }
  1526.            if ($in_where && $upper_data != 'WHERE') {
  1527.                $where_clause .= $arr[$i]['data'] . $sep;
  1528.  
  1529.                if (($arr[$i]['type'] == 'quote_backtick')
  1530.                 || ($arr[$i]['type'] == 'alpha_identifier')) {
  1531.                    $where_clause_identifiers[] = $arr[$i]['data'];
  1532.                }
  1533.            }
  1534.  
  1535.            if (isset($subresult['queryflags']['select_from'])
  1536.              && $subresult['queryflags']['select_from'] == 1
  1537.              && !$seen_order) {
  1538.                $unsorted_query .= $arr[$i]['data'];
  1539.  
  1540.                if ($arr[$i]['type'] != 'punct_bracket_open_round'
  1541.                && $arr[$i]['type'] != 'punct_bracket_close_round'
  1542.                && $arr[$i]['type'] != 'punct') {
  1543.                    $unsorted_query .= $sep;
  1544.                }
  1545.            }
  1546.  
  1547.            // clear $upper_data for next iteration
  1548.            $upper_data='';
  1549.  
  1550.            if ($collect_section_before_limit  && $arr[$i]['type'] != 'punct_queryend') {
  1551.                $section_before_limit .= $arr[$i]['data'] . $sep;
  1552.            } else {
  1553.                $section_after_limit .= $arr[$i]['data'] . $sep;
  1554.            }
  1555.  
  1556.  
  1557.         } // end for $i (loop #2)
  1558.  
  1559.  
  1560.         // -----------------------------------------------------
  1561.         // loop #3: foreign keys and MySQL 4.1.2+ TIMESTAMP options
  1562.         // (for now, check only the first query)
  1563.         // (for now, identifiers are assumed to be backquoted)
  1564.  
  1565.         // If we find that we are dealing with a CREATE TABLE query,
  1566.         // we look for the next punct_bracket_open_round, which
  1567.         // introduces the fields list. Then, when we find a
  1568.         // quote_backtick, it must be a field, so we put it into
  1569.         // the create_table_fields array. Even if this field is
  1570.         // not a timestamp, it will be useful when logic has been
  1571.         // added for complete field attributes analysis.
  1572.  
  1573.         $seen_foreign = FALSE;
  1574.         $seen_references = FALSE;
  1575.         $seen_constraint = FALSE;
  1576.         $foreign_key_number = -1;
  1577.         $seen_create_table = FALSE;
  1578.         $seen_create = FALSE;
  1579.         $in_create_table_fields = FALSE;
  1580.         $brackets_level = 0;
  1581.         $in_timestamp_options = FALSE;
  1582.         $seen_default = FALSE;
  1583.  
  1584.         for ($i = 0; $i < $size; $i++) {
  1585.         // DEBUG echo "<b>" . $arr[$i]['data'] . "</b> " . $arr[$i]['type'] . "<br />";
  1586.  
  1587.             if ($arr[$i]['type'] == 'alpha_reservedWord') {
  1588.                 $upper_data = strtoupper($arr[$i]['data']);
  1589.  
  1590.                 if ($upper_data == 'NOT' && $in_timestamp_options) {
  1591.                     $create_table_fields[$current_identifier]['timestamp_not_null'] = TRUE;
  1592.  
  1593.                 }
  1594.  
  1595.                 if ($upper_data == 'CREATE') {
  1596.                     $seen_create = TRUE;
  1597.                 }
  1598.  
  1599.                 if ($upper_data == 'TABLE' && $seen_create) {
  1600.                     $seen_create_table = TRUE;
  1601.                     $create_table_fields = array();
  1602.                 }
  1603.  
  1604.                 if ($upper_data == 'CURRENT_TIMESTAMP') {
  1605.                     if ($in_timestamp_options) {
  1606.                         if ($seen_default) {
  1607.                             $create_table_fields[$current_identifier]['default_current_timestamp'] = TRUE;
  1608.                         }
  1609.                     }
  1610.                 }
  1611.  
  1612.                 if ($upper_data == 'CONSTRAINT') {
  1613.                     $foreign_key_number++;
  1614.                     $seen_foreign = FALSE;
  1615.                     $seen_references = FALSE;
  1616.                     $seen_constraint = TRUE;
  1617.                 }
  1618.                 if ($upper_data == 'FOREIGN') {
  1619.                     $seen_foreign = TRUE;
  1620.                     $seen_references = FALSE;
  1621.                     $seen_constraint = FALSE;
  1622.                 }
  1623.                 if ($upper_data == 'REFERENCES') {
  1624.                     $seen_foreign = FALSE;
  1625.                     $seen_references = TRUE;
  1626.                     $seen_constraint = FALSE;
  1627.                 }
  1628.  
  1629.  
  1630.                 // Cases covered:
  1631.  
  1632.                 // [ON DELETE {CASCADE | SET NULL | NO ACTION | RESTRICT}]
  1633.                 // [ON UPDATE {CASCADE | SET NULL | NO ACTION | RESTRICT}]
  1634.  
  1635.                 // but we set ['on_delete'] or ['on_cascade'] to
  1636.                 // CASCADE | SET_NULL | NO_ACTION | RESTRICT
  1637.  
  1638.                 // ON UPDATE CURRENT_TIMESTAMP
  1639.  
  1640.                 if ($upper_data == 'ON') {
  1641.                     if ($arr[$i+1]['type'] == 'alpha_reservedWord') {
  1642.                         $second_upper_data = strtoupper($arr[$i+1]['data']);
  1643.                         if ($second_upper_data == 'DELETE') {
  1644.                             $clause = 'on_delete';
  1645.                         }
  1646.                         if ($second_upper_data == 'UPDATE') {
  1647.                             $clause = 'on_update';
  1648.                         }
  1649.                         if (isset($clause)
  1650.                         && ($arr[$i+2]['type'] == 'alpha_reservedWord'
  1651.  
  1652.                 // ugly workaround because currently, NO is not
  1653.                 // in the list of reserved words in sqlparser.data
  1654.                 // (we got a bug report about not being able to use
  1655.                 // 'no' as an identifier)
  1656.                            || ($arr[$i+2]['type'] == 'alpha_identifier'
  1657.                               && strtoupper($arr[$i+2]['data'])=='NO') )
  1658.                           ) {
  1659.                             $third_upper_data = strtoupper($arr[$i+2]['data']);
  1660.                             if ($third_upper_data == 'CASCADE'
  1661.                             || $third_upper_data == 'RESTRICT') {
  1662.                                 $value = $third_upper_data;
  1663.                             } elseif ($third_upper_data == 'SET'
  1664.                               || $third_upper_data == 'NO') {
  1665.                                 if ($arr[$i+3]['type'] == 'alpha_reservedWord') {
  1666.                                     $value = $third_upper_data . '_' . strtoupper($arr[$i+3]['data']);
  1667.                                 }
  1668.                             } elseif ($third_upper_data == 'CURRENT_TIMESTAMP') {
  1669.                                 if ($clause == 'on_update'
  1670.                                 && $in_timestamp_options) {
  1671.                                     $create_table_fields[$current_identifier]['on_update_current_timestamp'] = TRUE;
  1672.                                     $seen_default = FALSE;
  1673.                                 }
  1674.  
  1675.                             } else {
  1676.                                 $value = '';
  1677.                             }
  1678.                             if (!empty($value)) {
  1679.                                 $foreign[$foreign_key_number][$clause] = $value;
  1680.                             }
  1681.                             unset($clause);
  1682.                         } // endif (isset($clause))
  1683.                     }
  1684.                 }
  1685.  
  1686.             } // end of reserved words analysis
  1687.  
  1688.  
  1689.             if ($arr[$i]['type'] == 'punct_bracket_open_round') {
  1690.                 $brackets_level++;
  1691.                 if ($seen_create_table && $brackets_level == 1) {
  1692.                     $in_create_table_fields = TRUE;
  1693.                 }
  1694.             }
  1695.  
  1696.  
  1697.             if ($arr[$i]['type'] == 'punct_bracket_close_round') {
  1698.                 $brackets_level--;
  1699.                 if ($seen_references) {
  1700.                     $seen_references = FALSE;
  1701.                 }
  1702.                 if ($seen_create_table && $brackets_level == 0) {
  1703.                     $in_create_table_fields = FALSE;
  1704.                 }
  1705.             }
  1706.  
  1707.             if (($arr[$i]['type'] == 'alpha_columnAttrib')) {
  1708.                 $upper_data = strtoupper($arr[$i]['data']);
  1709.                 if ($seen_create_table && $in_create_table_fields) {
  1710.                     if ($upper_data == 'DEFAULT') {
  1711.                         $seen_default = TRUE;
  1712.                     }
  1713.                 }
  1714.             }
  1715.  
  1716.             // note: the "or" part here is a workaround for a bug
  1717.             // (see FIXME-2005-10-16)
  1718.             if (($arr[$i]['type'] == 'alpha_columnType') || ($arr[$i]['type'] == 'alpha_functionName' && $seen_create_table)) {
  1719.                 $upper_data = strtoupper($arr[$i]['data']);
  1720.                 if ($seen_create_table && $in_create_table_fields && isset($current_identifier)) {
  1721.                     $create_table_fields[$current_identifier]['type'] = $upper_data;
  1722.                     if ($upper_data == 'TIMESTAMP') {
  1723.                         $in_timestamp_options = TRUE;
  1724.                     } else {
  1725.                         $in_timestamp_options = FALSE;
  1726.                     }
  1727.                 }
  1728.             }
  1729.  
  1730.  
  1731.             if ($arr[$i]['type'] == 'quote_backtick' || $arr[$i]['type'] == 'alpha_identifier') {
  1732.  
  1733.                 if ($arr[$i]['type'] == 'quote_backtick') {
  1734.                     // remove backquotes
  1735.                     $identifier = str_replace('`', '', $arr[$i]['data']);
  1736.                 } else {
  1737.                     $identifier = $arr[$i]['data'];
  1738.                 }
  1739.  
  1740.                 if ($seen_create_table && $in_create_table_fields) {
  1741.                     $current_identifier = $identifier;
  1742.                     // warning: we set this one even for non TIMESTAMP type
  1743.                     $create_table_fields[$current_identifier]['timestamp_not_null'] = FALSE;
  1744.                 }
  1745.  
  1746.                 if ($seen_constraint) {
  1747.                     $foreign[$foreign_key_number]['constraint'] = $identifier;
  1748.                 }
  1749.  
  1750.                 if ($seen_foreign && $brackets_level > 0) {
  1751.                     $foreign[$foreign_key_number]['index_list'][] = $identifier;
  1752.                 }
  1753.  
  1754.                 if ($seen_references) {
  1755.                     // here, the first bracket level corresponds to the
  1756.                     // bracket of CREATE TABLE
  1757.                     // so if we are on level 2, it must be the index list
  1758.                     // of the foreign key REFERENCES
  1759.                     if ($brackets_level > 1) {
  1760.                         $foreign[$foreign_key_number]['ref_index_list'][] = $identifier;
  1761.                     } else {
  1762.                         // for MySQL 4.0.18, identifier is
  1763.                         // `table` or `db`.`table`
  1764.                         // the first pass will pick the db name
  1765.                         // the next pass will execute the else and pick the
  1766.                         // db name in $db_table[0]
  1767.                         if ($arr[$i+1]['type'] == 'punct_qualifier') {
  1768.                                 $foreign[$foreign_key_number]['ref_db_name'] = $identifier;
  1769.                         } else {
  1770.                         // for MySQL 4.0.16, identifier is
  1771.                         // `table` or `db.table`
  1772.                             $db_table = explode('.', $identifier);
  1773.                             if (isset($db_table[1])) {
  1774.                                 $foreign[$foreign_key_number]['ref_db_name'] = $db_table[0];
  1775.                                 $foreign[$foreign_key_number]['ref_table_name'] = $db_table[1];
  1776.                             } else {
  1777.                                 $foreign[$foreign_key_number]['ref_table_name'] = $db_table[0];
  1778.                             }
  1779.                         }
  1780.                     }
  1781.                 }
  1782.             }
  1783.         } // end for $i (loop #3)
  1784.  
  1785.  
  1786.         // Fill the $subresult array
  1787.  
  1788.         if (isset($create_table_fields)) {
  1789.             $subresult['create_table_fields'] = $create_table_fields;
  1790.         }
  1791.  
  1792.         if (isset($foreign)) {
  1793.             $subresult['foreign_keys'] = $foreign;
  1794.         }
  1795.  
  1796.         if (isset($select_expr_clause)) {
  1797.             $subresult['select_expr_clause'] = $select_expr_clause;
  1798.         }
  1799.         if (isset($from_clause)) {
  1800.             $subresult['from_clause'] = $from_clause;
  1801.         }
  1802.         if (isset($group_by_clause)) {
  1803.             $subresult['group_by_clause'] = $group_by_clause;
  1804.         }
  1805.         if (isset($order_by_clause)) {
  1806.             $subresult['order_by_clause'] = $order_by_clause;
  1807.         }
  1808.         if (isset($having_clause)) {
  1809.             $subresult['having_clause'] = $having_clause;
  1810.         }
  1811.         if (isset($where_clause)) {
  1812.             $subresult['where_clause'] = $where_clause;
  1813.         }
  1814.         if (isset($unsorted_query) && !empty($unsorted_query)) {
  1815.             $subresult['unsorted_query'] = $unsorted_query;
  1816.         }
  1817.         if (isset($where_clause_identifiers)) {
  1818.             $subresult['where_clause_identifiers'] = $where_clause_identifiers;
  1819.         }
  1820.  
  1821.         if (isset($position_of_first_select)) {
  1822.             $subresult['position_of_first_select'] = $position_of_first_select;
  1823.             $subresult['section_before_limit'] = $section_before_limit;
  1824.             $subresult['section_after_limit'] = $section_after_limit;
  1825.         }
  1826.  
  1827.         // They are naughty and didn't have a trailing semi-colon,
  1828.         // then still handle it properly
  1829.         if ($subresult['querytype'] != '') {
  1830.             $result[] = $subresult;
  1831.         }
  1832.         return $result;
  1833.     } // end of the "PMA_SQP_analyze()" function
  1834.  
  1835.  
  1836.     /**
  1837.      * Colorizes SQL queries html formatted
  1838.      *
  1839.      * @param  array   The SQL queries html formatted
  1840.      *
  1841.      * @return array   The colorized SQL queries
  1842.      *
  1843.      * @access public
  1844.      */
  1845.     function PMA_SQP_formatHtml_colorize($arr)
  1846.     {
  1847.         $i         = $GLOBALS['PMA_strpos']($arr['type'], '_');
  1848.         $class     = '';
  1849.         if ($i > 0) {
  1850.             $class = 'syntax_' . PMA_substr($arr['type'], 0, $i) . ' ';
  1851.         }
  1852.  
  1853.         $class     .= 'syntax_' . $arr['type'];
  1854.  
  1855.         //TODO: check why adding a "\n" after the </span> would cause extra
  1856.         //      blanks to be displayed:
  1857.         //      SELECT p . person_name
  1858.  
  1859.         return '<span class="' . $class . '">' . htmlspecialchars($arr['data']) . '</span>';
  1860.     } // end of the "PMA_SQP_formatHtml_colorize()" function
  1861.  
  1862.  
  1863.     /**
  1864.      * Formats SQL queries to html
  1865.      *
  1866.      * @param  array   The SQL queries
  1867.      * @param  string  mode
  1868.      * @param  integer starting token
  1869.      * @param  integer number of tokens to format, -1 = all
  1870.      *
  1871.      * @return string  The formatted SQL queries
  1872.      *
  1873.      * @access public
  1874.      */
  1875.     function PMA_SQP_formatHtml($arr, $mode='color', $start_token=0,
  1876.         $number_of_tokens=-1)
  1877.     {
  1878.         // then check for an array
  1879.         if (!is_array($arr)) {
  1880.             return htmlspecialchars($arr);
  1881.         }
  1882.         // first check for the SQL parser having hit an error
  1883.         if (PMA_SQP_isError()) {
  1884.             return htmlspecialchars($arr['raw']);
  1885.         }
  1886.         // else do it properly
  1887.         switch ($mode) {
  1888.             case 'color':
  1889.                 $str                                = '<span class="syntax">';
  1890.                 $html_line_break                    = '<br />';
  1891.                 break;
  1892.             case 'query_only':
  1893.                 $str                                = '';
  1894.                 $html_line_break                    = "\n";
  1895.                 break;
  1896.             case 'text':
  1897.                 $str                                = '';
  1898.                 $html_line_break                    = '<br />';
  1899.                 break;
  1900.         } // end switch
  1901.         $indent                                     = 0;
  1902.         $bracketlevel                               = 0;
  1903.         $functionlevel                              = 0;
  1904.         $infunction                                 = FALSE;
  1905.         $space_punct_listsep                        = ' ';
  1906.         $space_punct_listsep_function_name          = ' ';
  1907.         // $space_alpha_reserved_word = '<br />'."\n";
  1908.         $space_alpha_reserved_word                  = ' ';
  1909.  
  1910.         $keywords_with_brackets_1before            = array(
  1911.             'INDEX',
  1912.             'KEY',
  1913.             'ON',
  1914.             'USING'
  1915.         );
  1916.         $keywords_with_brackets_1before_cnt        = 4;
  1917.  
  1918.         $keywords_with_brackets_2before            = array(
  1919.             'IGNORE',
  1920.             'INDEX',
  1921.             'INTO',
  1922.             'KEY',
  1923.             'PRIMARY',
  1924.             'PROCEDURE',
  1925.             'REFERENCES',
  1926.             'UNIQUE',
  1927.             'USE'
  1928.         );
  1929.         // $keywords_with_brackets_2before_cnt = count($keywords_with_brackets_2before);
  1930.         $keywords_with_brackets_2before_cnt        = 9;
  1931.  
  1932.         // These reserved words do NOT get a newline placed near them.
  1933.         $keywords_no_newline               = array(
  1934.             'AS',
  1935.             'ASC',
  1936.             'DESC',
  1937.             'DISTINCT',
  1938.             'HOUR',
  1939.             'INTERVAL',
  1940.             'IS',
  1941.             'LIKE',
  1942.             'NOT',
  1943.             'NULL',
  1944.             'ON',
  1945.             'REGEXP'
  1946.         );
  1947.         $keywords_no_newline_cnt           = 12;
  1948.  
  1949.         // These reserved words introduce a privilege list
  1950.         $keywords_priv_list                = array(
  1951.             'GRANT',
  1952.             'REVOKE'
  1953.         );
  1954.         $keywords_priv_list_cnt            = 2;
  1955.  
  1956.         if ($number_of_tokens == -1) {
  1957.             $arraysize = $arr['len'];
  1958.         } else {
  1959.             $arraysize = $number_of_tokens;
  1960.         }
  1961.         $typearr   = array();
  1962.         if ($arraysize >= 0) {
  1963.             $typearr[0] = '';
  1964.             $typearr[1] = '';
  1965.             $typearr[2] = '';
  1966.             //$typearr[3] = $arr[0]['type'];
  1967.             $typearr[3] = $arr[$start_token]['type'];
  1968.         }
  1969.  
  1970.         $in_priv_list = FALSE;
  1971.         for ($i = $start_token; $i < $arraysize; $i++) {
  1972. // DEBUG echo "<b>" . $arr[$i]['data'] . "</b> " . $arr[$i]['type'] . "<br />";
  1973.             $before = '';
  1974.             $after  = '';
  1975.             $indent = 0;
  1976.             // array_shift($typearr);
  1977.             /*
  1978.             0 prev2
  1979.             1 prev
  1980.             2 current
  1981.             3 next
  1982.             */
  1983.             if (($i + 1) < $arraysize) {
  1984.                 // array_push($typearr, $arr[$i + 1]['type']);
  1985.                 $typearr[4] = $arr[$i + 1]['type'];
  1986.             } else {
  1987.                 //array_push($typearr, null);
  1988.                 $typearr[4] = '';
  1989.             }
  1990.  
  1991.             for ($j=0; $j<4; $j++) {
  1992.                 $typearr[$j] = $typearr[$j + 1];
  1993.             }
  1994.  
  1995.             switch ($typearr[2]) {
  1996.                 case 'white_newline':
  1997.                     $before     = '';
  1998.                     break;
  1999.                 case 'punct_bracket_open_round':
  2000.                     $bracketlevel++;
  2001.                     $infunction = FALSE;
  2002.                     // Make sure this array is sorted!
  2003.                     if (($typearr[1] == 'alpha_functionName') || ($typearr[1] == 'alpha_columnType') || ($typearr[1] == 'punct')
  2004.                         || ($typearr[3] == 'digit_integer') || ($typearr[3] == 'digit_hex') || ($typearr[3] == 'digit_float')
  2005.                         || (($typearr[0] == 'alpha_reservedWord')
  2006.                             && PMA_STR_binarySearchInArr(strtoupper($arr[$i - 2]['data']), $keywords_with_brackets_2before, $keywords_with_brackets_2before_cnt))
  2007.                         || (($typearr[1] == 'alpha_reservedWord')
  2008.                             && PMA_STR_binarySearchInArr(strtoupper($arr[$i - 1]['data']), $keywords_with_brackets_1before, $keywords_with_brackets_1before_cnt))
  2009.                         ) {
  2010.                         $functionlevel++;
  2011.                         $infunction = TRUE;
  2012.                         $after      .= ' ';
  2013.                     } else {
  2014.                         $indent++;
  2015.                         $after      .= ($mode != 'query_only' ? '<div class="syntax_indent' . $indent . '">' : ' ');
  2016.                     }
  2017.                     break;
  2018.                 case 'alpha_identifier':
  2019.                     if (($typearr[1] == 'punct_qualifier') || ($typearr[3] == 'punct_qualifier')) {
  2020.                         $after      = '';
  2021.                         $before     = '';
  2022.                     }
  2023.                     if (($typearr[3] == 'alpha_columnType') || ($typearr[3] == 'alpha_identifier')) {
  2024.                         $after      .= ' ';
  2025.                     }
  2026.                     break;
  2027.                 case 'punct_qualifier':
  2028.                     $before         = '';
  2029.                     $after          = '';
  2030.                     break;
  2031.                 case 'punct_listsep':
  2032.                     if ($infunction == TRUE) {
  2033.                         $after      .= $space_punct_listsep_function_name;
  2034.                     } else {
  2035.                         $after      .= $space_punct_listsep;
  2036.                     }
  2037.                     break;
  2038.                 case 'punct_queryend':
  2039.                     if (($typearr[3] != 'comment_mysql') && ($typearr[3] != 'comment_ansi') && $typearr[3] != 'comment_c') {
  2040.                         $after     .= $html_line_break;
  2041.                         $after     .= $html_line_break;
  2042.                     }
  2043.                     $space_punct_listsep               = ' ';
  2044.                     $space_punct_listsep_function_name = ' ';
  2045.                     $space_alpha_reserved_word         = ' ';
  2046.                     $in_priv_list                      = FALSE;
  2047.                     break;
  2048.                 case 'comment_mysql':
  2049.                 case 'comment_ansi':
  2050.                     $after         .= $html_line_break;
  2051.                     break;
  2052.                 case 'punct':
  2053.                     $before         .= ' ';
  2054.                     // workaround for
  2055.                     // select * from mytable limit 0,-1
  2056.                     // (a side effect of this workaround is that
  2057.                     // select 20 - 9
  2058.                     // becomes
  2059.                     // select 20 -9
  2060.                     // )
  2061.                     if ($typearr[3] != 'digit_integer') {
  2062.                        $after        .= ' ';
  2063.                     }
  2064.                     break;
  2065.                 case 'punct_bracket_close_round':
  2066.                     $bracketlevel--;
  2067.                     if ($infunction == TRUE) {
  2068.                         $functionlevel--;
  2069.                         $after     .= ' ';
  2070.                         $before    .= ' ';
  2071.                     } else {
  2072.                         $indent--;
  2073.                         $before    .= ($mode != 'query_only' ? '</div>' : ' ');
  2074.                     }
  2075.                     $infunction    = ($functionlevel > 0) ? TRUE : FALSE;
  2076.                     break;
  2077.                 case 'alpha_columnType':
  2078.                     if ($typearr[3] == 'alpha_columnAttrib') {
  2079.                         $after     .= ' ';
  2080.                     }
  2081.                     if ($typearr[1] == 'alpha_columnType') {
  2082.                         $before    .= ' ';
  2083.                     }
  2084.                     break;
  2085.                 case 'alpha_columnAttrib':
  2086.  
  2087.                     // ALTER TABLE tbl_name AUTO_INCREMENT = 1
  2088.                     // COLLATE LATIN1_GENERAL_CI DEFAULT
  2089.                     if ($typearr[1] == 'alpha_identifier' || $typearr[1] == 'alpha_charset') {
  2090.                         $before .= ' ';
  2091.                     }
  2092.                     if (($typearr[3] == 'alpha_columnAttrib') || ($typearr[3] == 'quote_single') || ($typearr[3] == 'digit_integer')) {
  2093.                         $after     .= ' ';
  2094.                     }
  2095.                     // workaround for
  2096.                     // select * from mysql.user where binary user="root"
  2097.                     // binary is marked as alpha_columnAttrib
  2098.                     // but should be marked as a reserved word
  2099.                     if (strtoupper($arr[$i]['data']) == 'BINARY'
  2100.                       && $typearr[3] == 'alpha_identifier') {
  2101.                         $after     .= ' ';
  2102.                     }
  2103.                     break;
  2104.                 case 'alpha_reservedWord':
  2105.                     // do not uppercase the reserved word if we are calling
  2106.                     // this function in query_only mode, because we need
  2107.                     // the original query (otherwise we get problems with
  2108.                     // semi-reserved words like "storage" which is legal
  2109.                     // as an identifier name)
  2110.  
  2111.                     if ($mode != 'query_only') {
  2112.                         $arr[$i]['data'] = strtoupper($arr[$i]['data']);
  2113.                     }
  2114.  
  2115.                     if ((($typearr[1] != 'alpha_reservedWord')
  2116.                         || (($typearr[1] == 'alpha_reservedWord')
  2117.                             && PMA_STR_binarySearchInArr(strtoupper($arr[$i - 1]['data']), $keywords_no_newline, $keywords_no_newline_cnt)))
  2118.                         && ($typearr[1] != 'punct_level_plus')
  2119.                         && (!PMA_STR_binarySearchInArr($arr[$i]['data'], $keywords_no_newline, $keywords_no_newline_cnt))) {
  2120.                         // do not put a space before the first token, because
  2121.                         // we use a lot of eregi() checking for the first
  2122.                         // reserved word at beginning of query
  2123.                         // so do not put a newline before
  2124.                         //
  2125.                         // also we must not be inside a privilege list
  2126.                         if ($i > 0) {
  2127.                             // the alpha_identifier exception is there to
  2128.                             // catch cases like
  2129.                             // GRANT SELECT ON mydb.mytable TO myuser@localhost
  2130.                             // (else, we get mydb.mytableTO )
  2131.                             //
  2132.                             // the quote_single exception is there to
  2133.                             // catch cases like
  2134.                             // GRANT ... TO 'marc'@'domain.com' IDENTIFIED...
  2135.                             //
  2136.                             // TODO: fix all cases and find why this happens
  2137.  
  2138.                             if (!$in_priv_list || $typearr[1] == 'alpha_identifier' || $typearr[1] == 'quote_single' || $typearr[1] == 'white_newline') {
  2139.                                 $before    .= $space_alpha_reserved_word;
  2140.                             }
  2141.                         } else {
  2142.                         // on first keyword, check if it introduces a
  2143.                         // privilege list
  2144.                             if (PMA_STR_binarySearchInArr($arr[$i]['data'], $keywords_priv_list, $keywords_priv_list_cnt)) {
  2145.                                 $in_priv_list = TRUE;
  2146.                             }
  2147.                         }
  2148.                     } else {
  2149.                         $before    .= ' ';
  2150.                     }
  2151.  
  2152.                     switch ($arr[$i]['data']) {
  2153.                         case 'CREATE':
  2154.                             if (!$in_priv_list) {
  2155.                                 $space_punct_listsep       = $html_line_break;
  2156.                                 $space_alpha_reserved_word = ' ';
  2157.                             }
  2158.                             break;
  2159.                         case 'EXPLAIN':
  2160.                         case 'DESCRIBE':
  2161.                         case 'SET':
  2162.                         case 'ALTER':
  2163.                         case 'DELETE':
  2164.                         case 'SHOW':
  2165.                         case 'DROP':
  2166.                         case 'UPDATE':
  2167.                         case 'TRUNCATE':
  2168.                         case 'ANALYZE':
  2169.                         case 'ANALYSE':
  2170.                             if (!$in_priv_list) {
  2171.                                 $space_punct_listsep       = $html_line_break;
  2172.                                 $space_alpha_reserved_word = ' ';
  2173.                             }
  2174.                             break;
  2175.                         case 'INSERT':
  2176.                         case 'REPLACE':
  2177.                             if (!$in_priv_list) {
  2178.                                 $space_punct_listsep       = $html_line_break;
  2179.                                 $space_alpha_reserved_word = $html_line_break;
  2180.                             }
  2181.                             break;
  2182.                         case 'VALUES':
  2183.                             $space_punct_listsep       = ' ';
  2184.                             $space_alpha_reserved_word = $html_line_break;
  2185.                             break;
  2186.                         case 'SELECT':
  2187.                             $space_punct_listsep       = ' ';
  2188.                             $space_alpha_reserved_word = $html_line_break;
  2189.                             break;
  2190.                         default:
  2191.                             break;
  2192.                     } // end switch ($arr[$i]['data'])
  2193.  
  2194.                     $after         .= ' ';
  2195.                     break;
  2196.                 case 'digit_integer':
  2197.                 case 'digit_float':
  2198.                 case 'digit_hex':
  2199.                     //TODO: could there be other types preceding a digit?
  2200.                     if ($typearr[1] == 'alpha_reservedWord') {
  2201.                         $after .= ' ';
  2202.                     }
  2203.                     if ($infunction && $typearr[3] == 'punct_bracket_close_round') {
  2204.                         $after     .= ' ';
  2205.                     }
  2206.                     if ($typearr[1] == 'alpha_columnAttrib') {
  2207.                         $before .= ' ';
  2208.                     }
  2209.                     break;
  2210.                 case 'alpha_variable':
  2211.                     // other workaround for a problem similar to the one
  2212.                     // explained below for quote_single
  2213.                     if (!$in_priv_list) {
  2214.                         $after      = ' ';
  2215.                     }
  2216.                     break;
  2217.                 case 'quote_double':
  2218.                 case 'quote_single':
  2219.                     // workaround: for the query
  2220.                     // REVOKE SELECT ON `base2\_db`.* FROM 'user'@'%'
  2221.                     // the @ is incorrectly marked as alpha_variable
  2222.                     // in the parser, and here, the '%' gets a blank before,
  2223.                     // which is a syntax error
  2224.                     if ($typearr[1] !='alpha_variable') {
  2225.                         $before        .= ' ';
  2226.                     }
  2227.                     if ($infunction && $typearr[3] == 'punct_bracket_close_round') {
  2228.                         $after     .= ' ';
  2229.                     }
  2230.                     break;
  2231.                 case 'quote_backtick':
  2232.                     if ($typearr[3] != 'punct_qualifier') {
  2233.                         $after     .= ' ';
  2234.                     }
  2235.                     if ($typearr[1] != 'punct_qualifier') {
  2236.                         $before    .= ' ';
  2237.                     }
  2238.                     break;
  2239.                 default:
  2240.                     break;
  2241.             } // end switch ($typearr[2])
  2242.  
  2243. /*
  2244.             if ($typearr[3] != 'punct_qualifier') {
  2245.                 $after             .= ' ';
  2246.             }
  2247.             $after                 .= "\n";
  2248. */
  2249.             $str .= $before . ($mode=='color' ? PMA_SQP_formatHTML_colorize($arr[$i]) : $arr[$i]['data']). $after;
  2250.         } // end for
  2251.         if ($mode=='color') {
  2252.             $str .= '</span>';
  2253.         }
  2254.  
  2255.         return $str;
  2256.     } // end of the "PMA_SQP_formatHtml()" function
  2257. }
  2258.  
  2259. /**
  2260.  * Builds a CSS rule used for html formatted SQL queries
  2261.  *
  2262.  * @param  string  The class name
  2263.  * @param  string  The property name
  2264.  * @param  string  The property value
  2265.  *
  2266.  * @return string  The CSS rule
  2267.  *
  2268.  * @access public
  2269.  *
  2270.  * @see    PMA_SQP_buildCssData()
  2271.  */
  2272. function PMA_SQP_buildCssRule($classname, $property, $value)
  2273. {
  2274.     $str     = '.' . $classname . ' {';
  2275.     if ($value != '') {
  2276.         $str .= $property . ': ' . $value . ';';
  2277.     }
  2278.     $str     .= '}' . "\n";
  2279.  
  2280.     return $str;
  2281. } // end of the "PMA_SQP_buildCssRule()" function
  2282.  
  2283.  
  2284. /**
  2285.  * Builds CSS rules used for html formatted SQL queries
  2286.  *
  2287.  * @return string  The CSS rules set
  2288.  *
  2289.  * @access public
  2290.  *
  2291.  * @global array   The current PMA configuration
  2292.  *
  2293.  * @see    PMA_SQP_buildCssRule()
  2294.  */
  2295. function PMA_SQP_buildCssData()
  2296. {
  2297.     global $cfg;
  2298.  
  2299.     $css_string     = '';
  2300.     foreach ($cfg['SQP']['fmtColor'] AS $key => $col) {
  2301.         $css_string .= PMA_SQP_buildCssRule('syntax_' . $key, 'color', $col);
  2302.     }
  2303.  
  2304.     for ($i = 0; $i < 8; $i++) {
  2305.         $css_string .= PMA_SQP_buildCssRule('syntax_indent' . $i, 'margin-left', ($i * $cfg['SQP']['fmtInd']) . $cfg['SQP']['fmtIndUnit']);
  2306.     }
  2307.  
  2308.     return $css_string;
  2309. } // end of the "PMA_SQP_buildCssData()" function
  2310.  
  2311. if ( ! defined( 'PMA_MINIMUM_COMMON' ) ) {
  2312.     /**
  2313.      * Gets SQL queries with no format
  2314.      *
  2315.      * @param  array   The SQL queries list
  2316.      *
  2317.      * @return string  The SQL queries with no format
  2318.      *
  2319.      * @access public
  2320.      */
  2321.     function PMA_SQP_formatNone($arr)
  2322.     {
  2323.         $formatted_sql = htmlspecialchars($arr['raw']);
  2324.         $formatted_sql = preg_replace("@((\015\012)|(\015)|(\012)){3,}@", "\n\n", $formatted_sql);
  2325.  
  2326.         return $formatted_sql;
  2327.     } // end of the "PMA_SQP_formatNone()" function
  2328.  
  2329.  
  2330.     /**
  2331.      * Gets SQL queries in text format
  2332.      *
  2333.      * @param  array   The SQL queries list
  2334.      *
  2335.      * @return string  The SQL queries in text format
  2336.      *
  2337.      * @access public
  2338.      */
  2339.     function PMA_SQP_formatText($arr)
  2340.     {
  2341.         /**
  2342.          * TODO WRITE THIS!
  2343.          */
  2344.          return PMA_SQP_formatNone($arr);
  2345.     } // end of the "PMA_SQP_formatText()" function
  2346. } // end if: minimal common.lib needed?
  2347.  
  2348. ?>
  2349.